DEPOSIUM GeoAI
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
DEPOSIUM GeoAI
Satellite observations, weather and spatial data — accessible through AI tools.
GeoAI turns geospatial data into structured, traceable results that an AI client can retrieve, analyse and explain. Ask for a weather forecast at a point, inspect vegetation over an area, or look for relationships in environmental time series. The server retrieves data and runs the calculations. Tools expose explicit inputs and structured results, with source and limit metadata where available.
GeoAI is a self-hosted Python MCP server. The
Model Context Protocol (MCP) lets compatible
AI applications call its tools. Install it with uv or build its Docker image,
then configure your MCP client to launch it locally or connect to your running
instance over HTTP. It works with compatible MCP clients independently of the
DEPOSIUM application. See installation options,
Docker deployment and
hosting and data flow.
Funded by FIERCE
GeoAI is funded by the FIERCE project through its Financial Support Programme. This support brings together research, geospatial engineering and market exploration to help DEPOSIUM work with Earth Observation and environmental data.
FIERCE receives European Union support through Horizon Europe, Grant Agreement 101177496. See the official project description. The authors are responsible for this repository's content; it does not represent an endorsement by the European Union or HADEA.
Related MCP server: copernicus-mcp
Team and contributions
The project combines complementary research, engineering and market expertise.
Contributor | Role in the project |
Project lead and coordination; architecture and implementation of the MCP layer, product direction, integration into DEPOSIUM and qualification of user workflows. | |
Geospatial data pipelines, reproducible processing, forecast integration and evaluation infrastructure. | |
Scientific methods for gradual-pattern mining; library development, experimental comparisons and research validation. | |
Market study and innovation strategy: identify relevant sectors, practical problems and conditions for adoption. |
The scientific foundations include Dickson Owuor and Anne Laurent's work on gradual-pattern mining and related collaborations. Method and software credits are recorded in CITATION.cff.
Start here
I want to… | Read |
Understand the project and its research question | |
Meet the project team | |
See what I can do with it | |
Choose a tool or try a first request | |
Choose how to install or host GeoAI | |
Connect my MCP client | |
Understand where the server runs and which data it receives | |
Run the server in a container | |
Configure providers and storage | |
Understand the scientific scope | |
Understand computation, providers and S3 storage | |
Compare delivered scope and next objectives | |
Review FIERCE technical evidence and reported KPI status | |
Develop, test or contribute | |
Cite the work or check reuse conditions | Copy a citation or BibTeX, sources and methods, licence and full notices |
Why GeoAI?
DEPOSIUM®, developed by The Seed Ship (TSS), helps people work with documents and knowledge. GeoAI extends that direction to data with a location and a time: satellite acquisitions, weather series, geographic features and their sources.
The guiding research question is:
Can we extract more knowledge with less computation?
The work connects data preparation, temporal analysis, gradual-pattern mining and AI-assisted exploration. It asks how to make complex environmental data usable while keeping computation explicit and reproducible. Computational and environmental efficiency are objectives to evaluate on defined workloads.
Within DEPOSIUM, these tools provide a foundation for connecting environmental observations to documents and conversational workflows. This repository delivers the independent GeoAI server; the consuming application supplies its interface, document retrieval, scheduling and notification delivery.
Capabilities
Work with… | What GeoAI provides | Tools |
Satellite observations | Find scenes, obtain band URLs, compute NDVI profiles and vegetation indicators, compare two observation windows. | |
Weather and climate | Daily forecasts for a point or zone, historical daily weather, monthly climate distributions and alignment with NDVI acquisitions. | |
Geographic layers | Select GeoParquet features by intersection, containment or distance. | |
Environmental time series | Discover attributes that vary together, test their recurrence across zone folds and calculate experimental explanatory indices. | |
Solar profiles | Validate or collect a bounded portfolio of hourly radiation data, with explicit provider-access configuration. |
The server advertises 16 tools with structured input/output contracts. An MCP
client can read geoai://capabilities/tools for the authoritative inventory and
geoai://guide/agent for workflow guidance. See the
plain-language tool reference and first calls.
From data sources to usable results
Each tool uses the relevant path below. Solid arrows show data and results; dashed arrows show supported storage operations.
flowchart LR
SatelliteSource["Satellite sources<br/>Sentinel-2 / STAC"]
WeatherSource["Weather sources<br/>Open-Meteo<br/>ERA5 / IFS / AIFS"]
Storage[("Your optional S3 store<br/>GeoParquet / artifacts")]
subgraph Server["Your GeoAI MCP server — local process, Docker or remote service"]
Satellite["Satellite / vegetation<br/>Rasterio / NDVI"]
Climate["Weather / climate<br/>Forecasts / normals"]
Analysis["Spatial queries / patterns<br/>DuckDB / optional so4gp"]
end
Client["Your MCP client<br/>Structured results<br/>Sources and limits"]
SatelliteSource --> Satellite --> Client
WeatherSource --> Climate --> Client
Storage --> Analysis --> Client
Storage -. "read climate series" .-> Climate
Satellite -. "ingestion writes" .-> Storage
Climate -. "explicit persistence" .-> Storage
Analysis -. "derived outputs" .-> StorageStorage is optional for storage-free tools. Supported writes and archive commands persist explicitly; every MCP response is not automatically written to S3. Permitted local Parquet inputs are also supported when explicitly enabled. Archive CLIs provide separate local/S3 workflows. The consuming application supplies UI, document retrieval, scheduling and notification delivery. See the architecture for source links and the objective/evidence index for dated proof.
Hosting and data flow
GeoAI must be running for a client to call its tools. Choose how to run it:
Local process (stdio): install the Python dependencies with
uvand configure the MCP client to launch GeoAI on your computer. The client exchanges requests and results directly with that process.HTTP service: deploy GeoAI with Python or Docker, on your computer or on infrastructure you control. Configure the client with the instance's
/mcpURL and bearer credentials. The operator of that instance controls its hosting, access and storage. Legacy SSE is also supported.
MCP defines how a client communicates with a server; it does not provide hosting
or require a central GeoAI collector. Packages distributed through npm may also
launch local MCP server programs. This project's installation uses Python/uv
or Docker.
The selected GeoAI instance receives the arguments of tool calls, such as coordinates, dates, variables or dataset references. Depending on the tool and configuration, it contacts satellite/weather providers, reads permitted local or S3 data, and performs supported storage writes. A local deployment can therefore still make outbound provider requests. Local file paths always refer to the server's filesystem, including when the server is hosted remotely.
The consuming application decides which conversation or document data it sends in tool calls and which returned results it passes to a language model. It must also enforce user and tenant permissions; a shared HTTP bearer credential only controls access to the GeoAI service. See the architecture for these boundaries and the optional S3 data flow.
Research and evidence
The engineering layer makes data and calculations accessible through MCP. The research layer investigates which interpretable relationships can be extracted and whether they help on a defined task. Experimental comparisons, including negative results, are kept reproducible through code, fixtures and source hashes. The optional pattern tools use native so4gp GRAANK and TGrad.
A pattern describes an association to assess; it does not establish a cause or a calibrated prediction. Explanatory indices are not event probabilities. NDVI measures vegetation greenness, with separate validation needed for claims about carbon or biodiversity. Weather results retain their actual provider, collection time and missing-data limits; model issuance remains unknown when unavailable.
These foundations can support further work in agriculture, environmental monitoring and renewable energy. New indicators and missing-data estimation need a suitable dataset, an explicit method and their own validation protocol.
Install GeoAI
You can install and operate your own instance; a DEPOSIUM account is not required. Choose the setup that fits your MCP client:
Setup | What runs where | What you need |
Your MCP client launches GeoAI on your computer. | Git, Python 3.14 and | |
GeoAI runs in a local container; your client connects to | Git, Docker Engine with Compose; a client that supports HTTP. | |
An operator runs GeoAI on their infrastructure; clients connect to its HTTPS URL. | The operator installs Python or Docker; client users need the URL and credentials. |
For either self-hosted installation, first clone this repository:
git clone https://github.com/theseedship/mcp_geoai_deposium.git
cd mcp_geoai_deposiumContinue with one of the setup sections below. The repository supplies the server and configuration examples; your chosen MCP application supplies the chat interface. Queries to external data providers need internet access and remain subject to those providers' access conditions.
Run locally
Install uv, then run the following from the cloned directory. This installs Python 3.14 and the locked CPU pattern runtime:
uv python install 3.14
uv sync --locked --extra patternsConfigure your MCP client to launch the server process. The following common
mcpServers configuration uses stdio; adapt its location/format to your client
and replace the directory with the absolute path to your checkout:
{
"mcpServers": {
"geoai": {
"command": "uv",
"args": ["--directory", "/absolute/path/to/geoai", "run", "--no-sync", "geoai-server"],
"env": {"MCP_TRANSPORT": "stdio"}
}
}
}The optional pattern profile includes so4gp and CPU PyTorch. It supports Linux, Windows and macOS 14+ on ARM64; the Torch-backed extras do not support Intel macOS. The dependency and platform policy is recorded in pyproject.toml.
For HTTP, choose a bearer secret of at least 32 characters and pass it to the server and client:
export GEOAI_MESH_AUTH_TOKEN="$(python3 -c 'import secrets; print(secrets.token_urlsafe(32))')"
MCP_TRANSPORT=http HOST=127.0.0.1 PORT=5001 uv run --no-sync geoai-serverThe MCP endpoint is http://127.0.0.1:5001/mcp; /health returns OK.
GEOAI_MESH_AUTH_TOKEN is a local server configuration name: any MCP HTTP client
can use it as an Authorization: Bearer … header. HTTP/SSE data-plane startup
requires this token. Stdio uses the parent process boundary instead.
Optional Docker deployment
The supplied Compose file starts only the GeoAI server. It binds to loopback, uses the locked CPU pattern dependencies and creates one data volume. From the cloned directory (the example uses Python 3 to generate a random bearer secret):
export GEOAI_MESH_AUTH_TOKEN="$(python3 -c 'import secrets; print(secrets.token_urlsafe(32))')"
docker compose up --build -d
curl http://127.0.0.1:5001/healthCompose builds the image from this checkout. After /health returns OK,
configure an HTTP-capable MCP client with http://127.0.0.1:5001/mcp and an
Authorization: Bearer ... header containing the same secret. The /mcp endpoint
speaks MCP; use your MCP application to call its tools.
No GPU, database or object-store service is launched. To use S3-backed tools,
provide your own endpoint and credentials. To change the published port, set
GEOAI_HOST_PORT in your shell, for example 5051.
Remote HTTP deployment
The operator installs the same Python service or builds the Docker image on
their own server or cloud platform, configures the provider/storage access they
need, and exposes /mcp through an authenticated HTTPS endpoint. The supplied
Compose file binds to loopback; remote access requires the operator to configure
HTTPS ingress or a reverse proxy for their deployment.
Client users then configure that instance's URL and bearer credentials. They do not need a local Python or Docker installation. The public repository supplies the server code; it does not supply a shared hosted endpoint or service account. The operator must manage user access and decide which datasets the instance can read. See hosting and data flow and configuration.
Try a first request
Once connected, list the available tools and ask your MCP client to call
forecast_query with:
{"latitude": 43.6, "longitude": 3.88, "forecast_days": 3, "provider": "auto", "write_output": false}This requests a three-day forecast at the supplied Montpellier coordinates without saving it to S3. The returned coordinates, provider/model, units, collection timestamp and missing-data metadata should remain visible in the client's answer. See first tool calls for satellite and NDVI examples. Stored-data tools additionally require your own configured datasets/storage; installing the server does not populate a climate archive or qualify patterns automatically.
Configuration
See .env.example for common server settings and src/config.py for the
complete validated settings. A local .env file is optional and ignored by Git.
Setting | Purpose |
|
|
| Network bind address and port; ignored for stdio |
| Optional HTTP bearer; required when enabling data-plane access |
| Satellite catalogue; defaults to public Earth Search |
| Your S3-compatible storage, when needed |
| Explicit opt-in to a confined local Parquet directory |
| Forecast endpoint and optional matching API key |
Storage is optional for starting the server. Local Parquet access is disabled
by default; enabling it requires an absolute allowed directory other than /.
S3 paths retain explicit tenant/space prefixes. Do not treat a supplied path or
an evidence digest as caller authorization.
Solar collection has separate opt-in settings in src/solar_pilot.py; an
example is examples/solar.env.example. Use the provider access and endpoint
appropriate to your use. External APIs, imagery and datasets retain their own
access conditions, attribution and licences.
Development
uv sync --locked --extra dev --extra patterns
uv run --no-sync ruff check .
uv run --no-sync ruff format --check .
OMP_NUM_THREADS=1 OPENBLAS_NUM_THREADS=1 MKL_NUM_THREADS=1 PYTHONHASHSEED=0 \
uv run --no-sync pytest tests/tests/live_acceptance.py is a separate opt-in harness requiring a running
server and configured test storage. The normal test suite runs offline with
synthetic or frozen fixtures. Packaged runtime examples retain their scientific
scope and provenance; they are not a certification of operational forecasts.
Public documentation is maintained in this README, the
MCP tools reference, architecture,
roadmap and curated evidence collection.
Only these selected public documentation paths are included. Other local project
documents, docs-private/, research-data/ and outputs/ remain excluded;
adding local documents does not expose them as MCP resources.
Data sources and attribution
GeoAI builds on the work of data producers, distributors and researchers. Please credit the sources actually used in your outputs, including the underlying weather model when a provider fallback occurs.
Data or method | Source and credit |
Weather and climate API access | |
ERA5 reanalysis | Copernicus Climate Change Service / ECMWF; dataset and DOI, accessed through Open-Meteo. |
IFS/AIFS forecasts | ECMWF open data, accessed through Open-Meteo; ECMWF terms. |
Sentinel-2 imagery and derived NDVI | ESA / Copernicus; Earth Search by Element 84. The catalogue also credits Sinergise processing and AWS hosting. |
Montpellier and Fos administrative boundaries | IGN, ADMIN EXPRESS COG; source and retrieval metadata in CITATION.cff. |
Lez catchment boundaries | IGN / OFB, distributed by Sandre: BD TOPAGE® Métropole 2026. |
Retained historical GFS example | NOAA / NCEP, obtained directly from the NOAA public archive, separately from Open-Meteo; usage conditions. |
Gradual-pattern mining uses so4gp by Dickson Owuor and Anne Laurent. Cite the methods used: GRAANK by Laurent, Lesot and Rifqi (2009), and fuzzy-temporal gradual patterns by Owuor, Laurent and Orero (2019). Core engineering libraries include FastMCP, Rasterio and DuckDB.
GeoAI aggregates weather series, derives NDVI and performs spatial/temporal transformations. Third-party data retain their own licences; the software's MIT licence does not relicense those data. NOTICE records attribution, modification notices and source-specific conditions; CITATION.cff contains bibliographic references. Preserve the applicable notices when displaying or redistributing results, and use the years and sources of the data you actually processed. API-access and commercial-use conditions are separate from the data licence.
Licence
The existing MIT licence is preserved in LICENSE. Third-party libraries
and data keep their own licences and attribution; see NOTICE and CITATION.cff for
scientific references. Optional ai dependencies are outside the default CPU
image and have separate upstream requirements.
Citation
If you use GeoAI in research, a report or another project, you can copy this software citation:
Nicolas Geysse, Jonathan Labéjof, Dickson Owuor & Amandine Raynaud (2026).
Deposium GeoAI (version 0.1.0) [Computer software].
https://deposium.ai/
Funded by FIERCE through its Financial Support Programme.
FIERCE receives European Union funding under Horizon Europe,
Grant Agreement 101177496.BibTeX
@software{deposium_geoai_2026,
author = {Geysse, Nicolas and Labéjof, Jonathan and Owuor, Dickson and Raynaud, Amandine},
title = {Deposium GeoAI},
year = {2026},
version = {0.1.0},
url = {https://deposium.ai/},
note = {Funded by FIERCE through its Financial Support Programme.
FIERCE receives European Union funding under Horizon Europe,
Grant Agreement 101177496.}
}For reproducibility, also record the commit SHA or release tag you used. Machine-readable citation metadata and references for the methods and data are available in CITATION.cff.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Real-time planetary signal engine and Model Context Protocol (MCP) server for autonomous AI agents.
Geospatial AI MCP server — satellite imagery, embeddings, weather, GNS governance
AI Reasoning Cache & Consensus Layer with 11 MCP tools via Streamable HTTP.
The official Model Context Protocol server for Ambee. It gives any MCP-compatible AI assistant — Claude, ChatGPT, Cursor, VS Code, Ollama, and more direct access to live air quality, pollen, and weather data. To get started, including information on signing up and obtaining your Ambee key, check out the Ambee documentation on https://docs.ambeedata.com
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceA Model Context Protocol server that enables efficient discovery and retrieval of NASA Earth Data for geospatial analysis.27BSD 3-Clause
- AlicenseNot gradedqualityBmaintenanceA self-hosted MCP server that gives LLM agents local, reproducible access to Copernicus environmental data including observations, reanalysis, forecasts, and climate indicators.42 PyPI16BSD 3-Clause

Chuk MCP STACofficial
AlicenseAqualityFmaintenanceA Model Context Protocol (MCP) server for searching STAC catalogs, downloading satellite bands, and creating composites via 21 tools.24Apache 2.0- FlicenseBqualityDmaintenanceA Python MCP server for discovering and analyzing Sentinel-2 L2A imagery, enabling AI agents to search scenes, check quality, and compute spectral indices like NDVI, NDWI, and NBR from remote COG windows.4-