Initial release of ERP-GPT-EU

.gitattributes

@@ -0,0 +1,6 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+data_api/*.pkl filter=lfs diff=lfs merge=lfs -text
+data_api/*.csv filter=lfs diff=lfs merge=lfs -text
+data_api/*.json filter=lfs diff=lfs merge=lfs -text
+gpt_resources/*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,183 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor  
+#  Cursor is an AI-powered code editor.`.cursorignore` specifies files/directories to 
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+.DS_Store

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kuangdai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,86 @@
+# ERP-GPT-EU
+
+This repository includes the data and code needed to deploy **[ERP-GPT-EU](https://chatgpt.com/g/g-690a45283b0081918ef79f0d2ab8964e-erp-gpt-eu)**, a tool-augmented GPT for querying and interpreting high-resolution European soil data.
+
+ERP-GPT-EU combines geographic resolution based on European GADM administrative regions with soil data access from the **LUCAS-MEGA** fused dataset. It can resolve user-specified places or coordinates, retrieve relevant soil properties, and generate soil data outputs through an API server. The GPT is designed for users such as soil scientists, agronomists, land managers, policymakers, and data analysts.
+
+The repository contains both the backend API server and the GPT configuration resources. The API server provides access to local soil and geographic data files, while the `gpt_resources` directory contains the prompt, knowledge file, OpenAPI schema, icon, and starting questions needed to configure the custom GPT.
+
+# Deployment
+
+## API Server
+
+Install the required Python packages:
+
+```bash
+pip install -r requirements.txt
+```
+
+Start the API server:
+
+```bash
+python app.py --port=<PORT>
+```
+
+For local debugging, you can expose the server through a temporary public tunnel. For example, using `localtunnel`:
+
+```bash
+npx localtunnel --port <PORT>
+```
+
+This will return a public URL such as:
+
+```text
+https://your-subdomain.loca.lt
+```
+
+Use this public URL when configuring the GPT action schema.
+
+## GPT Setup
+
+Go to [ChatGPT](https://chatgpt.com/) and create a custom GPT.
+
+Use the files in `gpt_resources/` to set up the GPT:
+
+```text
+gpt_resources/
+├── icon.png
+├── knowledge.md
+├── prompt.md
+├── schema.json
+└── starts.md
+```
+
+File descriptions:
+
+* `schema.json` (most important): the OpenAPI schema for GPT Actions. In the OpenAI custom GPT setup, this file defines the API endpoints that the GPT can call, including input parameters, response formats, and the public server URL.
+* `prompt.md` (most important): the top-level instructions for the GPT. In the OpenAI custom GPT setup, this content should be placed in the Instructions field. It defines the GPT's role, behavior, tool-use rules, response style, and constraints.
+* `knowledge.md`: the knowledge file uploaded to the GPT. In the OpenAI custom GPT setup, this file provides reference material that the GPT can search when answering questions. It should describe the dataset, available soil variables, geographic scope, terminology, and important usage notes.
+* `icon.png`: icon for the GPT.
+* `starts.md`: starting questions for users.
+
+Before uploading or pasting `schema.json`, replace the default server URL:
+
+```json
+{
+  "servers": [
+    {
+      "url": "https://api.erp-soilgpt.uk/"
+    }
+  ]
+}
+```
+
+with your own public API server address, for example:
+
+```json
+{
+  "servers": [
+    {
+      "url": "https://your-subdomain.loca.lt/"
+    }
+  ]
+}
+```
+
+After saving the GPT configuration, test it with a simple soil or location query to confirm that the GPT can call your API server successfully.

app.py

@@ -0,0 +1,238 @@
+import os
+
+from flask import Flask, request, jsonify
+
+from data_utils import LUCASSoilData
+from gadm_utils import GADMHandler
+from geo_utils import resolve_place
+
+app = Flask(__name__, static_folder="plots", static_url_path="/plots")
+
+gadm_handler = GADMHandler("data_api/gadm_tree_europe.pkl")
+soil_data = LUCASSoilData(table_path="data_api/data_table.csv",
+                          dict_path="data_api/data_dict.pkl",
+                          column_names_path="data_api/meta_column_names.json",
+                          gadm_handler=gadm_handler)
+
+
+# --- geo_utils API ---
+@app.route("/resolve_place", methods=["POST"])
+def api_resolve_place():
+    data = request.json
+    print("resolve_place input:", data)
+    result = resolve_place(
+        data.get("place_name"),
+        data.get("fallback"),
+        data.get("session_name")
+    )
+    print("resolve_place output:", result)
+    return jsonify(result)
+
+
+@app.route("/gadm/find_gid", methods=["POST"])
+def api_gadm_find_gid():
+    data = request.json
+    print("find_gid input:", data)
+    lat = data["lat"]
+    lon = data["lon"]
+    bbox_area = data.get("bbox_area")
+    return_all = data.get("return_all", False)
+
+    result = gadm_handler.find_gid(lat, lon, bbox_area, return_all)
+    print("find_gid output:", result)
+
+    if result is None or (isinstance(result, list) and not result):
+        return jsonify({
+            "status": "Failed. No matching GADM region found.",
+            "gid": None
+        })
+
+    if return_all:
+        return jsonify({
+            "status": f"Success. Found {len(result)} matching regions.",
+            "gids": result
+        })
+    else:
+        return jsonify({
+            "status": "Success. Found best matching region.",
+            "gid": result
+        })
+
+
+@app.route("/gadm/get_full_name", methods=["POST"])
+def api_gadm_get_full_name():
+    data = request.json
+    print("get_full_name input:", data)
+    gid = data.get("gid")
+    result = gadm_handler.get_full_name(gid)
+    output = {
+        "status": "Success. Full hierarchical name found." if result else f"Failed. GID '{gid}' not found.",
+        "full_name": result
+    }
+    print("get_full_name output:", output)
+    return jsonify(output)
+
+
+@app.route("/gadm/get_geometry_info", methods=["POST"])
+def api_gadm_geometry_info():
+    data = request.json
+    print("get_geometry_info input:", data)
+    gid = data.get("gid")
+    result = gadm_handler.get_geometry_info(gid)
+    if result is None:
+        output = {
+            "status": f"Failed. GID '{gid}' not found or has no geometry.",
+            "latitude": None,
+            "longitude": None,
+            "bbox_bounds": None,
+            "polygon_area": None,
+            "bbox_area": None
+        }
+    else:
+        output = {
+            "status": "Success. Geometry information retrieved.",
+            **result
+        }
+    print("get_geometry_info output:", output)
+    return jsonify(output)
+
+
+@app.route("/gadm/get_tree_info", methods=["POST"])
+def api_gadm_tree_info():
+    data = request.json
+    print("get_tree_info input:", data)
+    gid = data.get("gid")
+    result = gadm_handler.get_tree_info(gid)
+    if result is None:
+        output = {
+            "status": f"Failed. GID '{gid}' not found.",
+            "level": None,
+            "parent": None,
+            "children": None,
+            "siblings": None
+        }
+    else:
+        output = {
+            "status": "Success. Tree information retrieved.",
+            **result
+        }
+    print("get_tree_info output:", output)
+    return jsonify(output)
+
+
+@app.route("/gadm/get_quick_summary", methods=["POST"])
+def api_gadm_quick_summary():
+    data = request.json
+    print("get_quick_summary input:", data)
+    gid = data.get("gid")
+    summary = gadm_handler.quick_summary(gid)
+    status = "Success" if not summary.startswith("Invalid GID") else "Failed"
+    output = {"summary": summary, "status": status}
+    print("get_quick_summary output:", output)
+    return jsonify(output)
+
+
+# --- ISDASoilData APIs ---
+@app.route("/soil/get_point", methods=["POST"])
+def api_soil_get_point():
+    data = request.json
+    print("get_point input:", data)
+
+    data = request.get_json(silent=True) or {}
+    place = data.get("place")
+    properties = data.get("properties")
+    if place is None or not isinstance(properties, list) or len(properties) == 0:
+        return jsonify({
+            "query_input": {"place": place, "properties": properties, "session_name": data.get("session_name")},
+            "query_status": "Failed. Missing required fields: 'place' and non-empty 'properties'.",
+            "query_output": {}
+        }), 400
+
+    # Use server-side defaults if client omitted them
+    distance_top_k = int(data.get("distance_top_k", 20))
+    distance_limit = float(data.get("distance_limit", 200000))
+    session_name = data.get("session_name")
+
+    result = soil_data.get_point(
+        place=place,
+        properties=properties,
+        distance_top_k=distance_top_k,
+        distance_limit=distance_limit,
+        session_name=session_name,
+    )
+    print("get_point output:", result)
+    return jsonify(result)
+
+
+@app.route("/soil/get_map", methods=["POST"])
+def api_soil_get_map():
+    data = request.get_json(silent=True) or {}
+    print("get_map input:", data)
+
+    place = data.get("place")
+    properties = data.get("properties") or []
+    session_name = data.get("session_name")
+    kwargs = data.get("kwargs") or {}
+
+    # Basic input validation (mirror API contract)
+    if not session_name:
+        return jsonify({
+            "query_input": {"place": place, "properties": properties, "session_name": session_name},
+            "query_status": "Failed. Missing required field: session_name.",
+            "query_output": {}
+        }), 400
+    if place is None:
+        return jsonify({
+            "query_input": {"place": place, "properties": properties, "session_name": session_name},
+            "query_status": "Failed. Missing required field: place.",
+            "query_output": {}
+        }), 400
+    if not isinstance(properties, list) or len(properties) == 0:
+        return jsonify({
+            "query_input": {"place": place, "properties": properties, "session_name": session_name},
+            "query_status": "Failed. properties must be a non-empty list.",
+            "query_output": {}
+        }), 400
+
+    # Call core API
+    result = soil_data.get_map(place=place, properties=properties, session_name=session_name, **kwargs)
+    print("get_map raw output:", result.get("query_output", {}))
+
+    # Convert local file paths to public URLs under /plots/<session_name>/
+    try:
+        qo = result.get("query_output", {})
+        for label, path in list(qo.items()):
+            if isinstance(path, str) and path.endswith(".png") and os.path.exists(path):
+                filename = os.path.basename(path)
+                # app.static_url_path is "/plots"
+                public_url = f"{request.url_root.rstrip('/')}{app.static_url_path}/{session_name}/{filename}"
+                result["query_output"][label] = public_url
+    except Exception as e:
+        # Do not fail the whole response; annotate status
+        result["query_status"] = f"{result.get('query_status', 'Success')}\nNote: Failed to rewrite some URLs: {e}"
+
+    print("get_map with URLs:", result.get("query_output", {}))
+    return jsonify(result)
+
+
+@app.route("/health", methods=["GET"])
+def health_check():
+    print("health_check called")
+    return jsonify({"status": "OK"})
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Run Soil API server")
+    parser.add_argument(
+        "--host", default="0.0.0.0",
+        help="Host to bind (default: 0.0.0.0)"
+    )
+    parser.add_argument(
+        "--port", type=int, default=5050,
+        help="Port to listen on (default: 5050)"
+    )
+    args = parser.parse_args()
+
+    app.run(host=args.host, port=args.port)

data_api/data_dict.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b42ad2a1a1e8c092059c1b22e1589177e1ba70763bc232b91d1595189505aaef
+size 3934696791

data_api/data_table.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62276e90b45937fc626b5c8d4318ce152a4553b4b399680662675378b2d1defb
+size 722519601

data_api/gadm_tree_europe.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:443cfde775d41e9ee1cce5ee68ba0701983f4491201369cf888af698543b5dc9
+size 1782553909

data_api/meta_column_complete.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8eb79fcbcac181504c20099857462c2323dadb8a8bda9423916475ccf9025f5
+size 952082

data_api/meta_column_names.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d36b9bfe39e32c1959c3ef24b0963a990cb86b0c13b93416a92e3fdd8ef6382
+size 58158

data_api/meta_fused_datasets.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c48ce61060459cca00ea32b475a4ce8ef44634bd1f5cb69eac723a5dfe70b1f2
+size 33181

data_utils.py

@@ -0,0 +1,398 @@
+import json
+import pickle
+from typing import Tuple, Optional, List, Dict, Any
+
+import numpy as np
+import pandas as pd
+from geopy.distance import geodesic
+
+from gadm_utils import GADMHandler
+from geo_utils import resolve_place
+from plot_utils import scatter_plot
+import ast
+
+class LUCASSoilData:
+    def __init__(self, table_path: str, dict_path: str,
+                 column_names_path: str,
+                 gadm_handler: GADMHandler) -> None:
+
+        self.df = pd.read_csv(table_path, low_memory=False)
+        self.df["LAT_LONG"] = self.df["LAT_LONG"].apply(
+            lambda x: ast.literal_eval(x) if isinstance(x, str) else x
+        )
+
+        with open(column_names_path, 'r') as f:
+            self.column_names = json.load(f)["column_names"]
+
+        self.property_map = {}
+        for full_name in self.column_names:
+            base, unit = full_name.split("(", maxsplit=1) if "(" in full_name else (full_name, None)
+            if unit is not None:
+                unit = unit[:-1].strip()  # remove trailing ")"
+
+            theme, prop = [x.strip() for x in base.split(":", 1)]
+            self.property_map[prop] = (full_name, theme, unit)
+
+        with open(dict_path, 'rb') as f:
+            self.sample_dict = pickle.load(f)
+
+        self.gadm_handler = gadm_handler
+
+    def resolve_theme_property_unit(self, input_string: str) -> Tuple[str, str, str, Optional[str]]:
+        """
+        Resolve and return (full_name, theme, property, unit) from a user input string.
+        The user may provide:
+            - full form: "theme:property (unit)"
+            - partial form: "theme:property"
+            - property only: "property"
+        """
+
+        input_string = input_string.strip()
+
+        # Extract unit if present
+        if "(" in input_string:
+            base, input_unit = input_string.split("(", maxsplit=1)
+            input_unit = input_unit[:-1].strip()  # remove trailing ")"
+        else:
+            base, input_unit = input_string, None
+
+        # Extract theme + property
+        if ":" in base:
+            input_theme, input_property = [x.strip() for x in base.split(":", 1)]
+        else:
+            input_theme, input_property = None, base.strip()
+
+        # Property must exist
+        if input_property not in self.property_map:
+            raise ValueError(f"Property '{input_property}' not found in dataset.")
+
+        full_name, expected_theme, expected_unit = self.property_map[input_property]
+
+        # Validate theme if user supplied one
+        if input_theme is not None and input_theme != expected_theme:
+            raise ValueError(f"Theme mismatch: expected '{expected_theme}', got '{input_theme}'.")
+
+        # Validate unit if user supplied one
+        if input_unit is not None and input_unit != expected_unit:
+            raise ValueError(f"Unit mismatch for '{input_property}': expected '{expected_unit}', got '{input_unit}'.")
+
+        return full_name, expected_theme, input_property, expected_unit
+
+    def get_point(self,
+                  place: str | tuple[float, float],
+                  properties: List[str],
+                  distance_top_k: int = 20,
+                  distance_limit: float = 200000,
+                  session_name: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Retrieve soil data near a place, selecting the best among top-k nearest samples.
+
+        Rules:
+          1) Find top-k nearest samples (by squared distance, then geodesic meters).
+          2) Exclude samples farther than `distance_limit` (meters).
+          3) From remaining samples, choose the one with the most valid properties.
+             (valid = property exists AND sample[...] has non-None "value").
+             Tie-break: smaller distance wins.
+          4) If all survivors have zero valid properties, return Failed.
+          5) Resolver is strict: if user requests an unknown property, immediate Failed.
+
+        Output always contains `query_input` and `query_status`. Sample data is
+        included only for success or partial success cases.
+        """
+
+        # always include input record in response
+        query_input = {
+            "place": place,
+            "properties": properties,
+            "distance_limit": distance_limit,
+            "distance_top_k": distance_top_k,
+        }
+
+        # ---------- Resolve place → (lat, lon) ----------
+        try:
+            if isinstance(place, str):
+                if place not in self.gadm_handler.tree:
+                    resolved = resolve_place(place, session_name=session_name, gadm_handler=self.gadm_handler)
+                    gid = resolved.get("gid")
+                    if gid is None:
+                        return {
+                            "query_input": query_input,
+                            "query_status": f"Failed. Cannot resolve place: {place}",
+                            "query_output": {}
+                        }
+                else:
+                    gid = place
+
+                geom_info = self.gadm_handler.get_geometry_info(gid)
+                if geom_info is None:
+                    return {
+                        "query_input": query_input,
+                        "query_status": f"Failed. Cannot get geometry for place (GID): {place} ({gid})",
+                        "query_output": {}
+                    }
+
+                lat, lon = geom_info["latitude"], geom_info["longitude"]
+            else:
+                lat, lon = place
+        except Exception as e:
+            return {
+                "query_input": query_input,
+                "query_status": f"Failed. {str(e)}",
+                "query_output": {}
+            }
+
+        # ---------- Strict property resolution (fail if any invalid) ----------
+        resolved_props = []
+        try:
+            for input_prop in properties:
+                full_name, theme, prop, unit = self.resolve_theme_property_unit(input_prop)
+                resolved_props.append((theme, prop, input_prop))
+        except Exception as e:
+            return {
+                "query_input": query_input,
+                "query_status": f"Failed. {str(e)}",
+                "query_output": {}
+            }
+
+        # ---------- Find top-k nearest candidates ----------
+        try:
+            latlon = np.vstack(self.df["LAT_LONG"].values).astype(float)  # (N, 2)
+            d2 = (latlon[:, 0] - lat) ** 2 + (latlon[:, 1] - lon) ** 2
+
+            k = max(1, min(distance_top_k, len(d2)))
+            idx_k = np.argpartition(d2, kth=k - 1)[:k]
+
+            candidates = []
+            for idx in idx_k:
+                sample_lat, sample_lon = latlon[idx]
+                dist_m = geodesic((lat, lon), (sample_lat, sample_lon)).meters
+                candidates.append((idx, dist_m))
+
+            survivors = [(idx, dist_m) for (idx, dist_m) in candidates if dist_m <= distance_limit]
+            if not survivors:
+                return {
+                    "query_input": query_input,
+                    "query_status": f"Failed. No nearby samples within {distance_limit:g} m.",
+                    "query_output": {}
+                }
+
+        except Exception as e:
+            return {
+                "query_input": query_input,
+                "query_status": f"Failed. Error during nearest-point search: {str(e)}",
+                "query_output": {}
+            }
+
+        # ---------- Score survivors by valid property count, then distance ----------
+        def count_valid(idx: int) -> int:
+            row = self.df.iloc[idx]
+            src = self.sample_dict.get(row["id"], {})
+            valid = 0
+            for theme, prop, _orig in resolved_props:
+                try:
+                    val = src[theme][prop]["value"]
+                    if val is not None:
+                        valid += 1
+                except Exception:
+                    pass
+            return valid
+
+        scored = [(idx, dist, count_valid(idx)) for idx, dist in survivors]
+        scored.sort(key=lambda x: (-x[2], x[1]))  # most valid props, then nearest
+        best_idx, best_dist, best_valid = scored[0]
+
+        if best_valid == 0:
+            return {
+                "query_input": query_input,
+                "query_status": (
+                    "Failed. No sample within "
+                    f"{distance_limit:g} m contains any of the requested properties."
+                ),
+                "query_output": {}
+            }
+
+        # ---------- Build result for best candidate ----------
+        try:
+            row = self.df.iloc[best_idx]
+            source = self.sample_dict[row["id"]]
+        except Exception:
+            return {
+                "query_input": query_input,
+                "query_status": f"Failed. Sample data missing for best candidate.",
+                "query_output": {}
+            }
+
+        result = {}
+        for key in ["LAT_LONG", "GADM_IDS", "GADM_NAMES", "COUNTRY_CODE",
+                    "SAMPLE_DATE", "SAMPLE_DEPTH_RANGE_CM", "SAMPLE_SOURCE_DATASET"]:
+            result[key] = source.get(key)
+
+        failed_props = []
+        for theme, prop, original_input in resolved_props:
+            try:
+                val = source[theme][prop]["value"]
+                if val is not None:
+                    if theme not in result:
+                        result[theme] = {}
+                    result[theme][prop] = val
+                else:
+                    failed_props.append(original_input)
+            except Exception:
+                failed_props.append(original_input)
+
+        if failed_props and len(failed_props) < len(resolved_props):
+            status = (
+                    "Partial success. Some properties were not available: "
+                    + ", ".join(failed_props)
+                    + f". Distance to nearest sample (m): {best_dist:.1f}."
+            )
+        else:
+            status = f"Success. Distance to nearest sample (m): {best_dist:.1f}."
+
+        result["entry_key"] = row["id"]
+        return {
+            "query_output": result,
+            "query_input": query_input,
+            "query_status": status,
+        }
+
+    def get_map(self,
+                place: str | tuple[float, float, float],
+                properties: List[str],
+                session_name: Optional[str] = None,
+                **kwargs) -> Dict[str, Any]:
+        """
+        Generate scatter plots for the specified properties around a GADM region.
+
+        Returns:
+            {
+              "query_output": { "<full_name>": "<url or warning string>", ... },
+              "query_input": { "place": ..., "properties": [...] },
+              "query_status": "Success. N plot(s) generated." | "Failed. <reason>"
+            }
+        """
+        # Always include the input
+        query_input = {"place": place, "properties": properties}
+
+        # ---------- Resolve place → gid (and lat/lon if needed) ----------
+        try:
+            if isinstance(place, str):
+                if place not in self.gadm_handler.tree:
+                    resolved = resolve_place(place, session_name=session_name, gadm_handler=self.gadm_handler)
+                    gid = resolved.get("gid")
+                    if gid is None:
+                        return {"query_input": query_input,
+                                "query_status": f"Failed. Cannot resolve place: {place}",
+                                "query_output": {}}
+                else:
+                    gid = place
+            else:
+                # tuple expected: (lat, lon, bbox_area)
+                if len(place) != 3:
+                    return {"query_input": query_input,
+                            "query_status": "Failed. Tuple `place` must be (lat, lon, bbox_area).",
+                            "query_output": {}}
+                lat, lon, bbox_area = place
+                gid = self.gadm_handler.find_gid(lat, lon, bbox_area)
+                if gid is None:
+                    return {"query_input": query_input,
+                            "query_status": "Failed. No matching GADM region found for given coordinates.",
+                            "query_output": {}}
+            geom_info = self.gadm_handler.get_geometry_info(gid)
+            if geom_info is None:
+                return {"query_input": query_input,
+                        "query_status": f"Failed. Cannot get geometry for place (GID): {gid}",
+                        "query_output": {}}
+        except Exception as e:
+            return {"query_input": query_input, "query_status": f"Failed. {str(e)}",
+                    "query_output": {}}
+
+        # ---------- Strict property resolution (fail if any invalid) ----------
+        resolved = []
+        try:
+            for input_prop in properties:
+                full_name, theme, prop, unit = self.resolve_theme_property_unit(input_prop)
+                resolved.append((full_name, theme, prop, unit))
+        except Exception as e:
+            return {"query_input": query_input, "query_status": f"Failed. {str(e)}", "query_output": {}}
+
+        if len(resolved) > 5:
+            return {"query_input": query_input,
+                    "query_status": "Failed. API does not accept more than 5 properties.",
+                    "query_output": {}}
+
+        # ---------- Compute map extent using gid + siblings ----------
+        try:
+            siblings = self.gadm_handler.get_tree_info(gid)["siblings"]
+            gids = [gid] + siblings
+
+            polygon = self.gadm_handler.get_polygon(gid)
+            minx, miny, maxx, maxy = polygon.bounds
+
+            # 100% margin
+            dlat = (maxy - miny) or 1.0
+            dlon = (maxx - minx) or 1.0
+            lat_min, lat_max = miny - dlat, maxy + dlat
+            lon_min, lon_max = minx - dlon, maxx + dlon
+        except Exception as e:
+            return {"query_input": query_input, "query_status": f"Failed. {str(e)}", "query_output": {}}
+
+        # ---------- Region filter using LAT_LONG ----------
+        try:
+            latlon = np.vstack(self.df["LAT_LONG"].values).astype(float)  # shape (N,2)
+            lats, lons = latlon[:, 0], latlon[:, 1]
+            mask = (lats >= lat_min) & (lats <= lat_max) & (lons >= lon_min) & (lons <= lon_max)
+            df_region = self.df[mask]
+        except Exception as e:
+            return {"query_input": query_input, "query_status": f"Failed. {str(e)}", "query_output": {}}
+
+        # ---------- Plot helper (returns URL or warning string) ----------
+        def plot_one(full_name: str, prop: str) -> str:
+            try:
+                if full_name not in df_region.columns:
+                    return "Skipped. No valid data."
+
+                # Build [lat, lon, value]
+                values = pd.to_numeric(df_region[full_name], errors="coerce")
+                ok = values.notna()
+                if not ok.any():
+                    return "Skipped. No valid data."
+
+                # extract lat/lon for the same rows
+                latlon_sub = np.vstack(df_region.loc[ok, "LAT_LONG"].values).astype(float)
+                data = np.column_stack([latlon_sub[:, 0], latlon_sub[:, 1], values.loc[ok].astype(float).values])
+
+                # numeric vs categorical: if after coercion we have floats, treat as numeric.
+                # If you need categorical, you can branch by dtype before coercion.
+                img_path = scatter_plot(
+                    gadm_handler=self.gadm_handler,
+                    data=data,
+                    is_categorical=False,
+                    short_name=prop,
+                    long_name=full_name,
+                    map_boundary_gadm_gids=gids,
+                    map_limits="gadm_first",
+                    session_name=session_name,
+                    **kwargs
+                )
+                return img_path
+            except Exception:
+                return "Skipped. No valid data."
+
+        # ---------- Generate outputs (flat) ----------
+        query_output: Dict[str, str] = {}
+        for full_name, theme, prop, unit in resolved:
+            query_output[full_name] = plot_one(full_name, prop)
+
+        # ---------- Status ----------
+        n_plots = sum(1 for v in query_output.values() if isinstance(v, str) and v.endswith(".png"))
+        if n_plots >= 1:
+            status = f"Success. {n_plots} plot{'s' if n_plots != 1 else ''} generated."
+        else:
+            status = "Failed. No plots generated."
+
+        return {
+            "query_output": query_output,
+            "query_input": query_input,
+            "query_status": status,
+        }

gadm_utils.py

@@ -0,0 +1,232 @@
+import pickle
+from typing import Dict, Any, Optional, Union, List
+
+import numpy as np
+from shapely.geometry import Point
+from shapely.strtree import STRtree
+from shapely.wkb import loads
+
+
+class GADMHandler:
+    """
+    Handler for querying GADM hierarchy and geometry, built from preprocessed .gpkg files.
+    """
+
+    def __init__(self, path: str = "data_api/gadm_tree_europe.pkl") -> None:
+        """
+        Load the GADM tree and construct a spatial index on leaf geometries.
+
+        Args:
+            path (str): Path to the pickled tree file.
+        """
+        with open(path, "rb") as f:
+            raw_tree = pickle.load(f)
+
+        self.tree: Dict[str, Dict[str, Any]] = {}
+        for gid, node in raw_tree.items():
+            node = node.copy()
+            if node["geometry"] is not None:
+                node["geometry"] = loads(node["geometry"])
+            self.tree[gid] = node
+
+        leaf_items = [
+            (gid, node["geometry"])
+            for gid, node in self.tree.items()
+            if node["geometry"] is not None and not node["children"]
+        ]
+        self.leaf_polys = [geom for _, geom in leaf_items]
+        self.leaf_gid_map = {id(geom): gid for gid, geom in leaf_items}
+        self.leaf_tree = STRtree(self.leaf_polys)
+
+    def find_gid(
+            self, lat: float, lon: float, bbox_area: float = None, return_all: bool = False
+    ) -> Union[str, List[str], None]:
+        """
+        Find the best GADM GID that contains the given point (lat, lon),
+        optionally selecting the closest match by bounding box area.
+
+        Args:
+            lat (float): Latitude in degrees.
+            lon (float): Longitude in degrees.
+            bbox_area (float, optional): Area to match against polygon bounding box area (in degrees²);
+                                         if not provided, return the smallest region.
+            return_all (bool, optional): If True, return all matched GIDs up the tree; else return best match.
+
+        Returns:
+            str or list[str] or None: Best matching GID(s), or None if no polygon contains the point.
+        """
+        point = Point(lon, lat)
+        gids = []
+        areas = []
+
+        for poly_id in self.leaf_tree.query(point):
+            poly = self.leaf_polys[poly_id]
+            if poly.contains(point):
+                leaf_gid = self.leaf_gid_map[id(poly)]
+
+                # Traverse upward to collect candidates
+                current_gid = leaf_gid
+                while current_gid:
+                    node = self.tree.get(current_gid)
+                    if node["geometry"] is not None:
+                        minx, miny, maxx, maxy = node["geometry"].bounds
+                        if minx > maxx:  # Wraparound correction
+                            maxx += 360.0
+                        poly_bbox_area = abs((maxx - minx) * (maxy - miny))
+                        areas.append(poly_bbox_area)
+                        gids.append(current_gid)
+
+                    current_gid = node["parent"]
+
+                break  # Use only the first containing leaf polygon
+
+        if not gids:
+            return None
+        if return_all:
+            return gids  # Ordered from leaf to root
+        if bbox_area is None:
+            bbox_area = 0.0
+        areas = np.array(areas)
+        return gids[np.argmin(np.abs(areas - bbox_area))]
+
+    def get_polygon(self, gid: str) -> Optional[Any]:
+        """
+        Get the shapely geometry for a given GADM ID.
+        """
+        node = self.tree.get(gid)
+        return node["geometry"] if node else None
+
+    def get_full_name(self, gid: str) -> Optional[str]:
+        """
+        Get the full hierarchical name of a GADM region.
+        """
+        if gid not in self.tree:
+            return None
+
+        names = []
+        while gid in self.tree:
+            node = self.tree[gid]
+            names.append(node["name"] or "UNKNOWN")
+            gid = node["parent"]
+            if gid is None:
+                break
+
+        return "; ".join(names)
+
+    def get_geometry_info(self, gid: str) -> Optional[Dict[str, Any]]:
+        """
+        Get geometric metadata for the polygon of a GADM region.
+        """
+        polygon = self.get_polygon(gid)
+        if polygon is None:
+            return None
+
+        centroid = polygon.centroid
+        lon_c, lat_c = centroid.x, centroid.y
+        minx, miny, maxx, maxy = polygon.bounds
+        if minx > maxx:
+            maxx += 360.0
+
+        return {
+            "latitude": lat_c,
+            "longitude": lon_c,
+            "bbox_bounds": (miny, maxy, minx, maxx),  # (lat_min, lat_max, lon_min, lon_max)
+            "polygon_area": polygon.area,
+            "bbox_area": abs((maxx - minx) * (maxy - miny))
+        }
+
+    def get_tree_info(self, gid: str) -> Optional[Dict[str, Any]]:
+        """
+        Get hierarchical metadata for a GADM region.
+        """
+        node = self.tree.get(gid)
+        if node is None:
+            return None
+
+        parent = node["parent"]
+        own_polygon = node.get("geometry")
+        siblings = []
+
+        if own_polygon and not own_polygon.is_empty:
+            if parent is None:
+                # Level-0: compare with other level-0 regions
+                candidates = [
+                    (gid2, node2["geometry"])
+                    for gid2, node2 in self.tree.items()
+                    if node2["level"] == 0 and gid2 != gid and node2.get("geometry")
+                ]
+            else:
+                # Use other children of the same parent
+                candidates = [
+                    (sibling_gid, self.tree[sibling_gid]["geometry"])
+                    for sibling_gid in self.tree[parent]["children"]
+                    if sibling_gid != gid and self.tree[sibling_gid].get("geometry")
+                ]
+
+            for gid2, poly2 in candidates:
+                try:
+                    if own_polygon.touches(poly2) or own_polygon.intersects(poly2):
+                        siblings.append(gid2)
+                except Exception:  # noqa
+                    continue  # Catch topology errors etc.
+
+        siblings = sorted(siblings)
+
+        return {
+            "level": node["level"],
+            "parent": parent,
+            "children": sorted(node["children"]),
+            "siblings": siblings
+        }
+
+    def get_full_info(self, gid: str) -> Optional[Dict[str, Any]]:
+        """
+        Get complete metadata for a GADM region, including name, geometry, and hierarchy.
+        """
+        if gid not in self.tree:
+            return None
+        return {
+            "full_name": self.get_full_name(gid),
+            "geometry": self.get_geometry_info(gid),
+            "tree": self.get_tree_info(gid)
+        }
+
+    def quick_summary(self, gid: str) -> str:
+        """
+        Produce a human-readable summary of a GADM region.
+        Useful for GPT-based tools and debugging.
+        """
+        info = self.get_full_info(gid)
+        if not info:
+            return f"Invalid GID: {gid}"
+        name = info["full_name"] or "UNKNOWN"
+        level = info["tree"]["level"]
+        lat = info["geometry"]["latitude"]
+        lon = info["geometry"]["longitude"]
+        return f"{name} (GID={gid}, level={level}, lat={lat:.4f}, lon={lon:.4f})"
+
+
+def main():
+    from geo_utils import resolve_place
+    handler = GADMHandler()
+
+    place_info = resolve_place("Cowley, Oxford", gadm_handler=handler)
+
+    gid = place_info["gid"]
+    info = handler.get_full_info(gid)
+    if info is None:
+        print(f"GID '{gid}' not found.")
+        return
+
+    print("\n--- GADM Metadata ---")
+    for key, val in info.items():
+        if isinstance(val, dict):
+            print(f"{key}:")
+            for sub_key, sub_val in val.items():
+                print(f"  {sub_key}: {sub_val}")
+        else:
+            print(f"{key}: {val}")
+
+
+if __name__ == "__main__":
+    main()

geo_utils.py

@@ -0,0 +1,210 @@
+import re
+import time
+import warnings
+from typing import Dict, Any, Optional
+
+import pycountry
+from geopy.exc import GeocoderTimedOut, GeocoderServiceError
+from geopy.geocoders import Nominatim
+
+from gadm_utils import GADMHandler
+
+
+def resolve_place(
+        place_name: str,
+        fall_back_country: Optional[str] = None,
+        session_name: Optional[str] = None,
+        gadm_handler: Optional[GADMHandler] = None,
+) -> Dict[str, Any]:
+    """
+    Resolve a place name to coordinates using Nominatim,
+    with fallback to country via pycountry + GADMHandler.
+    """
+
+    def fail(status: str) -> Dict[str, Any]:
+        return {
+            "status": status,
+            "used_name": None,
+            "latitude": None,
+            "longitude": None,
+            "bbox_area": None,
+            "gid": None
+        }
+
+    def compute_bbox_area_from_nominatim(bbox) -> Optional[float]:
+        try:
+            lat_min, lat_max = float(bbox[0]), float(bbox[1])
+            lon_min, lon_max = float(bbox[2]), float(bbox[3])
+            if lon_min > lon_max:
+                lon_max += 360.0
+            return abs((lat_max - lat_min) * (lon_max - lon_min))
+        except Exception:
+            return None
+
+    def geocode(query: str, max_retries: int = 3, backoff: float = 1.0):
+        for attempt in range(1, max_retries + 1):
+            try:
+                return geocoder.geocode(query, timeout=5, geometry="geojson")
+            except (GeocoderTimedOut, GeocoderServiceError) as e:
+                if attempt == max_retries:
+                    warnings.warn(
+                        f"Geocoding failed: {query}\n{type(e).__name__}: {e}",
+                        RuntimeWarning,
+                    )
+                    return None
+                time.sleep(backoff * attempt)
+            except Exception as e:
+                if attempt == max_retries:
+                    warnings.warn(
+                        f"Unexpected error: {query}\n{type(e).__name__}: {e}",
+                        RuntimeWarning,
+                    )
+                    return None
+                time.sleep(backoff * attempt)
+
+    # --- Step 0: validate input ---
+    if not isinstance(place_name, str) or not place_name.strip():
+        return fail("Invalid input: place_name must be a non-empty string.")
+
+    # --- setup geocoder ---
+    identifier = "ERP_SOIL_GPT"
+    if session_name:
+        identifier += "_" + re.sub(r"[^a-zA-Z0-9_]", "_", session_name)
+    geocoder = Nominatim(user_agent=identifier)
+
+    # --- Step 0: try direct GADM match (aliases only) ---
+    if gadm_handler:
+
+        def norm(s: str) -> str:
+            return s.strip().lower()
+
+        place_norm = norm(place_name)
+
+        for gid, node in gadm_handler.tree.items():
+            raw_aliases = node.get("aliases", [])
+            aliases = {norm(a) for a in raw_aliases}
+            aliases.add(norm(node["name"]))
+            aliases.add(norm(gid))
+            if not aliases:
+                continue
+
+            if place_norm in aliases:
+                geom_info = gadm_handler.get_geometry_info(gid)
+                if geom_info is None:
+                    return fail(
+                        f"Matched GADM node '{gid}' but geometry is missing."
+                    )
+
+                return {
+                    "status": "Resolved by direct GADM alias match.",
+                    "used_name": place_name,
+                    "latitude": geom_info["latitude"],
+                    "longitude": geom_info["longitude"],
+                    "bbox_area": geom_info["bbox_area"],
+                    "gid": gid,
+                }
+
+    # --- Step 1: try full place name ---
+    query = place_name
+    if fall_back_country and fall_back_country not in query:
+        query += f", {fall_back_country}"
+
+    result = geocode(query)
+    if result:
+        try:
+            lat = float(result.latitude)
+            lon = float(result.longitude)
+        except (TypeError, ValueError):
+            return fail("Geocoding succeeded but returned invalid coordinates.")
+
+        bbox_area = compute_bbox_area_from_nominatim(
+            result.raw.get("boundingbox")
+        )
+
+        return {
+            "status": "Success. Resolved by Nominatim.",
+            "used_name": query,
+            "latitude": lat,
+            "longitude": lon,
+            "bbox_area": bbox_area,
+            "gid": gadm_handler.find_gid(lat, lon, bbox_area)
+            if gadm_handler
+            else None,
+        }
+
+    # --- Step 2: try country via Nominatim ---
+    if fall_back_country:
+        result = geocode(fall_back_country)
+        if result:
+            try:
+                lat = float(result.latitude)
+                lon = float(result.longitude)
+            except (TypeError, ValueError):
+                return fail("Fallback succeeded but returned invalid coordinates.")
+
+            bbox_area = compute_bbox_area_from_nominatim(
+                result.raw.get("boundingbox")
+            )
+
+            return {
+                "status": (
+                    f"Fallback. Failed with '{place_name}', "
+                    f"succeeded with '{fall_back_country}' by Nominatim."
+                ),
+                "used_name": fall_back_country,
+                "latitude": lat,
+                "longitude": lon,
+                "bbox_area": bbox_area,
+                "gid": gadm_handler.find_gid(lat, lon, bbox_area)
+                if gadm_handler
+                else None,
+            }
+
+    # --- Step 3: offline country fallback via pycountry + GADMHandler ---
+    if fall_back_country and gadm_handler:
+        try:
+            country = pycountry.countries.lookup(fall_back_country)
+        except LookupError:
+            country = None
+
+        if country:
+            alpha3 = country.alpha_3
+            geom_info = gadm_handler.get_geometry_info(alpha3)
+            if geom_info:
+                return {
+                    "status": (
+                        f"Fallback. Failed with '{place_name}', "
+                        f"succeeded with '{fall_back_country}' by PyCountry."
+                    ),
+                    "used_name": country.name,
+                    "latitude": geom_info["latitude"],
+                    "longitude": geom_info["longitude"],
+                    "bbox_area": geom_info["bbox_area"],
+                    "gid": alpha3,
+                }
+
+    # --- Step 4: complete failure ---
+    return fail("Failed.")
+
+
+def main():
+    handler = GADMHandler("data_api/gadm_tree_europe.pkl")
+
+    place = "Balkan"
+    fallback = None
+
+    t0 = time.time()
+    result = resolve_place(
+        place_name=place,
+        fall_back_country=fallback,
+        gadm_handler=handler,
+    )
+    print("Seconds:", time.time() - t0)
+
+    print("\n--- Resolution Result ---")
+    for k, v in result.items():
+        print(f"{k}: {v}")
+
+
+if __name__ == "__main__":
+    main()

gpt_resources/knowledge.md

@@ -0,0 +1,802 @@
+=========Start of knowledge_api.md=========
+This document **`knowledge_api.md`** introduces the APIs we expose.
+It focuses on high-level understanding and recommended usage patterns.
+For exact request/response definitions, refer to the API schema.
+
+---
+
+# Geographic APIs
+
+These APIs support flexible geographic reasoning and are designed to be used **modularly and sequentially**.
+
+| API                           | Purpose                                     | When to call                                                       |
+|-------------------------------|---------------------------------------------|--------------------------------------------------------------------|
+| /resolve_place(place_name, …) | Place text → coordinates (and possibly GID) | First step for user-provided place names (Nominatim-backed)        |
+| /gadm/find_gid(lat, lon, …)   | Coordinates → GADM region(s)                | When WGS84 coordinates (and scale) are provided or can be inferred |
+| /gadm/get_tree_info(gid)      | Administrative hierarchy navigation         | To move up, down, or across admin levels                           |
+| /gadm/get_full_name(gid)      | GID → full human-readable name              | To present regions in natural language                             |
+| /gadm/get_geometry_info(gid)  | Geometry summary (centroid, bbox, area)     | When spatial characteristics are required                          |
+| /gadm/get_quick_summary(gid)  | One-line region description                 | When a concise description is sufficient                           |
+
+The **GID (GADM ID)** is the central reference of the geographic system.
+
+User input typically starts as either:
+
+- a **place name** (vague), or
+- **latitude/longitude** coordinates (precise).
+
+Use `/resolve_place` or `/gadm/find_gid` to obtain the corresponding GID.
+Once a GID is available, it can be used to retrieve administrative context,
+geometry, and human-readable descriptions.
+`/gadm/get_tree_info` is particularly useful for associative reasoning across
+administrative levels.
+
+In practice, **work with GID whenever possible**.
+If appropriate, the GID may be exposed directly in the response.
+
+The `bbox_area` parameter acts as a **scale hint** (unit: degree² under WGS84),
+not as a strict spatial boundary.
+
+---
+
+## GADM Hierarchy Extension (Europe-Level Root)
+
+In **standard GADM**, the highest administrative level is the **country**.
+
+In this API, the hierarchy is **explicitly extended above the country level**
+to support continent-scale and regional queries.
+The **root of the hierarchy is `Europe`**, not individual countries.
+
+Between `Europe` and individual countries, the hierarchy includes **exactly two
+additional levels**, and no others:
+
+1. **Directional regions**, based on continental orientation  
+   (Northern, Southern, Eastern, Western, Central Europe)
+
+2. **Conventional geographic regions**, based on widely accepted geographic usage  
+   (e.g. Scandinavian, Balkan, British Isles)
+
+These two levels are **API-level extensions** and are **not part of the original
+GADM release**.
+
+They:
+- have valid **GIDs**,
+- participate in `/gadm/find_gid` and `/gadm/get_tree_info`,
+- can be used directly with `/soil/get_map` for large-scale queries.
+
+Example resolved hierarchy:
+
+```
+Cowley → Oxford → Oxfordshire → England → United Kingdom → British Isles → Northern Europe → Europe
+```
+
+---
+
+# Data Retrieval APIs
+
+These APIs retrieve **soil property data** either at a single location or as
+rendered maps over an area.
+They are typically used **after geographic resolution** and require a place
+reference plus a list of property names.
+
+## API Overview
+
+| API                                   | Purpose                                       | When to call                                              |
+|---------------------------------------|-----------------------------------------------|-----------------------------------------------------------|
+| /soil/get_point(place, properties, …) | Retrieve property values at a single location | When many properties are needed at a local scale          |
+| /soil/get_map(place, properties, …)   | Generate property maps (image URLs)           | When a few properties are needed across a geographic area |
+
+Conceptually, `/soil/get_point` emphasizes **depth and detail** at a specific
+location, while `/soil/get_map` emphasizes **spatial coverage** across an area.
+
+## Notes on input
+
+- `place` may be:
+    - a text string (e.g. `"Umbria, Italy"`),
+    - `(lat, lon)` for `/soil/get_point`,
+    - `(lat, lon, bbox_area)` for `/soil/get_map`.
+- `properties` must be valid column names (see `meta_column_names.json`).
+  Property names are flexible; for  
+  `biomass:bacterial_biomass (nmol FAME g⁻¹ soil)`, all following are equivalent:
+    - `biomass:bacterial_biomass (nmol FAME g⁻¹ soil)`
+    - `biomass:bacterial_biomass`
+    - `bacterial_biomass`
+- For `/soil/get_map`, a maximum of **8 properties per call** is enforced to limit latency.
+  Larger requests should be split into meaningful subsets.
+- `/soil/get_point` does not limit the number of properties.
+- Soil-specific properties default to **topsoil** unless the property name explicitly
+  specifies a depth qualifier (e.g. `bulk_density_subsoil`).
+
+## Notes on output
+
+- `/soil/get_point` returns values from the best-matching nearby sample,
+  selected from the top-k nearest candidates under a distance threshold.
+  In addition to property values, the response may include **sample-level
+  metadata**, such as:
+    - contributing source datasets,
+    - distance-to-sample or distance-to-grid indicators,
+    - other uncertainty-related fields.
+      This makes `/soil/get_point` suitable for **in-depth inspection** of individual samples.
+- If the requested properties include `ASSETS:photos`, `/soil/get_point` also returns
+  associated **photo URLs** when available.
+- `/soil/get_map` focuses on **spatial patterns at scale**.
+  It aggregates many samples within the target region and does not expose
+  per-sample metadata or uncertainty details.
+  Each requested property produces either:
+    - a plot URL, or
+    - a warning message.
+- All responses include `query_input` and `query_status`.
+  Plot URLs should be displayed **inline immediately** to support rapid visual
+  inspection and iterative analysis.
+
+---
+
+**END of `knowledge_api.md`**
+=========End of knowledge_api.md=========
+
+=========Start of knowledge_dataset.md=========
+The document **`knowledge_dataset.md`** provides the canonical description of the **LUCAS-MEGA** fused dataset.
+It defines the dataset composition, metadata schema, and supporting lookup resources.
+This document should be treated as the definitive reference for dataset-level questions.
+
+---
+
+# Knowledge Base: LUCAS-MEGA Dataset
+
+The **LUCAS-MEGA** dataset provides harmonized soil and ecosystem properties for samples collected across Europe.
+
+- It is a **data fusion product** built from **60+ datasets** hosted by **ESDAC** (European Soil Data Centre).
+- The dataset is organized as a **single long-wide table**:
+    - **Rows**: soil samples (≈ **72,000**)
+    - **Columns**: measured or derived properties (≈ **1,000**)
+- Data can be accessed through APIs in both **sample-wise (row)** and **property-wise (column)** modes.
+
+---
+
+## 1. Samples (Rows)
+
+Approximately **90%** of samples originate from **LUCAS soil surveys**
+(2012, 2015, 2018, 2019).
+The remaining **~10%** are harmonized from **EU-HYDI** and **SPADE/M**.
+
+The name *LUCAS-MEGA* reflects LUCAS as the primary sample backbone.
+
+---
+
+## 2. Properties (Columns)
+
+Each sample contains a set of native measurements (e.g. organic carbon).
+Additional datasets are fused into the same table to expand property coverage.
+
+Two fusion modes are used:
+
+| Fusion Type      | Description                                                                               |
+|------------------|-------------------------------------------------------------------------------------------|
+| **LUCAS-native** | Source data are already sample-aligned with LUCAS; values are merged by sample ID.        |
+| **Map-based**    | Source data are raster maps; values are sampled from the nearest grid cell to the sample. |
+|                  | A `distance_to_grid` value is stored as an uncertainty indicator.                         |
+
+Understanding a property requires consulting its metadata in **`meta_column_complete.json`**
+(≈ 1,000 entries).
+
+Example:
+
+```json
+{
+  "texture:clay_percentage (%)": {
+    "source_datasets": [
+      "european-hydropedological-data-inventory-eu-hydi-database-0",
+      "lucas-2009-topsoil-data",
+      "lucas-2015-topsoil-data-switzerland",
+      "lucas-2018-topsoil-data",
+      "lucas2015-topsoil-data",
+      "spadem"
+    ],
+    "distance_to_grid_stats (m)": {
+      "min": 0.0,
+      "max": 0.0,
+      "mean": 0.0,
+      "std": 0.0,
+      "median": 0.0
+    },
+    "null_fraction": 0.295,
+    "description": "Mass percentage of clay-sized particles (<2 µm) in the fine earth fraction (<2 mm) of the soil sample."
+  }
+}
+```
+
+### Metadata Fields
+
+| Field                        | Meaning                                                           |
+|------------------------------|-------------------------------------------------------------------|
+| `texture`                    | **Theme** (organizational grouping; not exhaustive or exclusive). |
+| `clay_percentage`            | Property name within the theme.                                   |
+| `%`                          | Unit (omitted if dimensionless).                                  |
+| `source_datasets`            | Source datasets contributing to the column.                       |
+| `distance_to_grid_stats (m)` | Distance statistics for map-based fusion (0 for LUCAS-native).    |
+| `null_fraction`              | Fraction of missing values in the column.                         |
+| `description`                | Human-readable definition of the property.                        |
+
+---
+
+### Fast Access to Column Names
+
+For property selection, you do **not** need to load `meta_column_complete.json`.
+
+A lightweight helper file, **`meta_column_names.json`**, provides the full list of column
+names without metadata and is intended for fast lookup and validation.
+
+Most column names are already interpretable within the soil science domain.
+When additional detail is needed (e.g. source datasets or uncertainty),
+refer to `meta_column_complete.json`.
+
+---
+
+## 3. Source Dataset Metadata
+
+Metadata for all contributing datasets is stored in **`meta_fused_datasets.json`**, including:
+
+| Key / Value   | Description                                                          |
+|---------------|----------------------------------------------------------------------|
+| dataset key   | Identifier used in `source_datasets` in `meta_column_complete.json`. |
+| `title`       | Official dataset title.                                              |
+| `abstract`    | Official dataset summary.                                            |
+| `dataset_url` | Link to full dataset documentation.                                  |
+
+All source datasets are provided by **ESDAC**.
+
+---
+
+## 4. Retrieval APIs
+
+Data access is supported through both **row-wise** and **column-wise** APIs.
+Refer to **`knowledge_api.md`** for usage patterns, request formats, and examples.
+
+---
+
+**END of `knowledge_dataset.md`**
+=========End of knowledge_dataset.md=========
+
+=========Start of meta_column_names.json=========
+```json
+{
+  "column_names": [
+    "ASSETS:photos",
+    "biodiversity:climate_change_pressure_index",
+    "biodiversity:genetically_modified_organism_use_pressure_index",
+    "biodiversity:habitat_fragmentation_pressure_index",
+    "biodiversity:industrial_pollution_pressure_index",
+    "biodiversity:intensive_human_exploitation_pressure_index",
+    "biodiversity:land_use_change_pressure_index",
+    "biodiversity:organic_matter_decline_pressure_index",
+    "biodiversity:radioactivity_pressure_index",
+    "biodiversity:soil_biological_functions_threat_index",
+    "biodiversity:soil_compaction_pressure_index",
+    "biodiversity:soil_erosion_pressure_index",
+    "biodiversity:soil_fauna_threat_index",
+    "biodiversity:soil_microorganisms_threat_index",
+    "biodiversity:soil_salinity_pressure_index",
+    "biomass:basal_respiration_general (\u00b5L O\u2082 g\u207b\u00b9 soil h\u207b\u00b9)",
+    "biomass:basal_respiration_landcover (\u00b5L O\u2082 g\u207b\u00b9 soil h\u207b\u00b9)",
+    "biomass:microbial_biomass_general (\u00b5g C\u2098\u1d62c g\u207b\u00b9 soil)",
+    "biomass:microbial_biomass_landcover (\u00b5g C\u2098\u1d62c g\u207b\u00b9 soil)",
+    "biomass:respiratory_quotient_general (\u00b5L O\u2082 \u00b5g\u207b\u00b9 C\u2098\u1d62c h\u207b\u00b9)",
+    "biomass:respiratory_quotient_landcover (\u00b5L O\u2082 \u00b5g\u207b\u00b9 C\u2098\u1d62c h\u207b\u00b9)",
+    "biomass:soil_biomass_productivity_cropland",
+    "carbon:CaCO3_content (g/kg)",
+    "carbon:SOC_saturation_ratio",
+    "carbon:carbon_deposition_flux_accelerated_revised_model (MgC ha\u207b\u00b9 yr\u207b\u00b9)",
+    "carbon:carbon_deposition_flux_accelerated_scenario (MgC ha\u207b\u00b9 yr\u207b\u00b9)",
+    "carbon:carbon_deposition_flux_current_revised_model (MgC ha\u207b\u00b9 yr\u207b\u00b9)",
+    "carbon:carbon_deposition_flux_current_scenario (MgC ha\u207b\u00b9 yr\u207b\u00b9)",
+    "carbon:carbon_deposition_flux_no_erosion_scenario (MgC ha\u207b\u00b9 yr\u207b\u00b9)",
+    "carbon:carbon_erosion_flux_accelerated_revised_model (MgC ha\u207b\u00b9 yr\u207b\u00b9)",
+    "carbon:carbon_erosion_flux_accelerated_scenario (MgC ha\u207b\u00b9 yr\u207b\u00b9)",
+    "carbon:carbon_erosion_flux_current_revised_model (MgC ha\u207b\u00b9 yr\u207b\u00b9)",
+    "carbon:carbon_erosion_flux_current_scenario (MgC ha\u207b\u00b9 yr\u207b\u00b9)",
+    "carbon:carbon_erosion_flux_no_erosion_scenario (MgC ha\u207b\u00b9 yr\u207b\u00b9)",
+    "carbon:eroded_carbon_stock (t ha\u207b\u00b9)",
+    "carbon:eroded_soc_content (g/kg)",
+    "carbon:estimated_organic_carbon_density_subsoil (t ha\u207b\u00b9)",
+    "carbon:estimated_organic_carbon_density_topsoil (t ha\u207b\u00b9)",
+    "carbon:observed_vs_typical_soc_index",
+    "carbon:observed_vs_typical_soc_index_confidence_zone",
+    "carbon:organic_carbon_content (g/kg)",
+    "carbon:organic_carbon_content_subsoil_ESDB (g/kg)",
+    "carbon:organic_carbon_content_topsoil (g/kg)",
+    "carbon:organic_carbon_content_topsoil_ESDB (g/kg)",
+    "carbon:soc_change_2009_2018 (g C kg\u207b\u00b9 yr\u207b\u00b9)",
+    "carbon:topsoil_OC_prediction_mean (g/kg)",
+    "carbon:topsoil_OC_prediction_std (g/kg)",
+    "chemical:electrical_conductivity (mS/m)",
+    "chemical:pH_in_CaCl2",
+    "chemical:pH_in_H2O",
+    "chemical:pH_in_H2O_EFSA",
+    "climate:annual_precipitation (mm)",
+    "climate:annual_temperature (\u00b0C)",
+    "crop_plant:apples_fraction (%)",
+    "crop_plant:barley_fraction (%)",
+    "crop_plant:berries_fraction (%)",
+    "crop_plant:citrus_fraction (%)",
+    "crop_plant:common_wheat_fraction (%)",
+    "crop_plant:cover_crop_fraction_5th_percentile (\u2031)",
+    "crop_plant:cover_crop_fraction_95th_percentile (\u2031)",
+    "crop_plant:cover_crop_fraction_median (\u2031)",
+    "crop_plant:cover_crop_fraction_std (\u2031)",
+    "crop_plant:durum_wheat_fraction (%)",
+    "crop_plant:effective_rooting_depth (cm)",
+    "crop_plant:fallow_fraction (%)",
+    "crop_plant:hops_fraction (%)",
+    "crop_plant:maize_crop_fraction (%)",
+    "crop_plant:oats_fraction (%)",
+    "crop_plant:olives_fraction (%)",
+    "crop_plant:other_crops_fraction (%)",
+    "crop_plant:pastures_fraction (%)",
+    "crop_plant:potatoes_fraction (%)",
+    "crop_plant:pulses_fraction (%)",
+    "crop_plant:rapeseed_fraction (%)",
+    "crop_plant:rye_fraction (%)",
+    "crop_plant:soya_fraction (%)",
+    "crop_plant:sugar_beet_fraction (%)",
+    "crop_plant:sunflower_fraction (%)",
+    "crop_plant:vineyards_fraction (%)",
+    "erosion:c_factor_cover_management",
+    "erosion:erodible_by_wind_fraction",
+    "erosion:k_factor_based_on_soil_texture (t ha h ha\u207b\u00b9 MJ\u207b\u00b9 mm\u207b\u00b9)",
+    "erosion:k_factor_based_on_soil_texture_uncertainty (t ha h ha\u207b\u00b9 MJ\u207b\u00b9 mm\u207b\u00b9)",
+    "erosion:k_factor_from_glosem_model (t ha h ha\u207b\u00b9 MJ\u207b\u00b9 mm\u207b\u00b9)",
+    "erosion:k_factor_lucas (t ha h ha\u207b\u00b9 MJ\u207b\u00b9 mm\u207b\u00b9)",
+    "erosion:k_factor_lucas_with_stoniness (t ha h ha\u207b\u00b9 MJ\u207b\u00b9 mm\u207b\u00b9)",
+    "erosion:k_factor_with_saturated_hydraulic_conductivity (t ha h ha\u207b\u00b9 MJ\u207b\u00b9 mm\u207b\u00b9)",
+    "erosion:k_factor_with_saturated_hydraulic_conductivity_uncertainty (t ha h ha\u207b\u00b9 MJ\u207b\u00b9 mm\u207b\u00b9)",
+    "erosion:ls_factor_slope_length_and_steepness",
+    "erosion:net_erosion_rate_PESERA (t ha\u207b\u00b9 yr\u207b\u00b9)",
+    "erosion:net_erosion_rate_WaTEM_SEDEM (t ha\u207b\u00b9 yr\u207b\u00b9)",
+    "erosion:p_factor_support_practices",
+    "erosion:r_factor_2050_projection (MJ mm ha\u207b\u00b9 h\u207b\u00b9 yr\u207b\u00b9)",
+    "erosion:r_factor_annual_mean (MJ mm ha\u207b\u00b9 h\u207b\u00b9 yr\u207b\u00b9)",
+    "erosion:r_factor_annual_std (MJ mm ha\u207b\u00b9 h\u207b\u00b9 yr\u207b\u00b9)",
+    "erosion:r_factor_erosivity_density (MJ ha\u207b\u00b9 h\u207b\u00b9 per mm precipitation)",
+    "erosion:r_factor_erosivity_ratio",
+    "erosion:r_factor_mann_kendall",
+    "erosion:r_factor_rainfall (MJ mm ha\u207b\u00b9 h\u207b\u00b9 yr\u207b\u00b9)",
+    "erosion:r_factor_trend_linear (MJ mm ha\u207b\u00b9 h\u207b\u00b9 per year)",
+    "erosion:r_factor_weighted_density",
+    "erosion:soil_displacement_estimate (t ha\u207b\u00b9 yr\u207b\u00b9)",
+    "erosion:soil_loss_by_water (t ha\u207b\u00b9 yr\u207b\u00b9)",
+    "fertility:K_extractable (mg/kg)",
+    "fertility:N_extractable (g/kg)",
+    "fertility:P_available_stock (kg ha\u207b\u00b9)",
+    "fertility:P_extractable (mg/kg)",
+    "fertility:P_total_concentration_topsoil (mg/kg)",
+    "fertility:P_total_stock_topsoil (kg ha\u207b\u00b9)",
+    "hydraulic:field_capacity_water_content (cm\u00b3 cm\u207b\u00b3)",
+    "hydraulic:field_capacity_water_content_EFSA (cm\u00b3/cm\u00b3)",
+    "hydraulic:saturated_hydraulic_conductivity (cm/day)",
+    "hydraulic:saturated_water_content (cm\u00b3 cm\u207b\u00b3)",
+    "hydraulic:topographic_wetness_index",
+    "hydraulic:total_available_water_capacity_subsoil_ESDB (mm)",
+    "hydraulic:total_available_water_capacity_subsoil_SMU_ESDB (mm)",
+    "hydraulic:total_available_water_capacity_topsoil_ESDB (mm)",
+    "hydraulic:total_available_water_capacity_topsoil_SMU_ESDB (mm)",
+    "hydraulic:wilting_point_water_content (cm\u00b3 cm\u207b\u00b3)",
+    "land_degradation:aridity_index_mean_cropland",
+    "land_degradation:land_multi_degradation_index_agricultural_lands",
+    "land_degradation:soil_erosion_exceeding_10Mg_ha_yr (t ha\u207b\u00b9 yr\u207b\u00b9)",
+    "land_site:nighttime_light_intensity",
+    "land_site:solar_radiation_input (W/m\u00b2)",
+    "mass_density:bulk_density (g/cm\u00b3)",
+    "mass_density:bulk_density_0_10cm (g/cm\u00b3)",
+    "mass_density:bulk_density_10_20cm (g/cm\u00b3)",
+    "mass_density:bulk_density_subsoil_ESDB (g/cm\u00b3)",
+    "mass_density:bulk_density_topsoil_EFSA (g/cm\u00b3)",
+    "mass_density:bulk_density_topsoil_ESDB (g/cm\u00b3)",
+    "mass_density:packing_density (g/cm\u00b3)",
+    "organic_matter:organic_matter_content (g/kg)",
+    "texture:clay_percentage (%)",
+    "texture:clay_percentage_subsoil_ESDB (%)",
+    "texture:clay_percentage_topsoil_ESDB (%)",
+    "texture:coarse_percentage (%)",
+    "texture:coarse_percentage_subsoil_ESDB (%)",
+    "texture:coarse_percentage_topsoil_ESDB (%)",
+    "texture:sand_percentage (%)",
+    "texture:sand_percentage_subsoil_ESDB (%)",
+    "texture:sand_percentage_topsoil_ESDB (%)",
+    "texture:silt_percentage (%)",
+    "texture:silt_percentage_subsoil_ESDB (%)",
+    "texture:silt_percentage_topsoil_ESDB (%)",
+    "topography_geology:digital_elevation_model (m)",
+    "topography_geology:elevation (m)",
+    "topography_geology:slope (deg)",
+    "trace_elements:As_concentration_1km_res (mg/kg)",
+    "trace_elements:As_concentration_5km_res (mg/kg)",
+    "trace_elements:As_concentration_kurtosis",
+    "trace_elements:As_concentration_mean (log10 mg/kg)",
+    "trace_elements:As_concentration_skewness",
+    "trace_elements:As_concentration_std (log10 mg/kg)",
+    "trace_elements:As_concentration_variance_1km_res (mg\u00b2/kg\u00b2)",
+    "trace_elements:Cd_concentration (mg/kg)",
+    "trace_elements:Cd_concentration_1km_res (mg/kg)",
+    "trace_elements:Cd_concentration_5km_res (mg/kg)",
+    "trace_elements:Cd_concentration_variance_1km_res (mg\u00b2/kg\u00b2)",
+    "trace_elements:Co_concentration_1km_res (mg/kg)",
+    "trace_elements:Co_concentration_variance_1km_res (mg\u00b2/kg\u00b2)",
+    "trace_elements:Cr_concentration_1km_res (mg/kg)",
+    "trace_elements:Cr_concentration_5km_res (mg/kg)",
+    "trace_elements:Cr_concentration_variance_1km_res (mg\u00b2/kg\u00b2)",
+    "trace_elements:Cu_concentration (mg/kg)",
+    "trace_elements:Cu_concentration_1km_res (mg/kg)",
+    "trace_elements:Cu_concentration_5km_res (mg/kg)",
+    "trace_elements:Cu_concentration_variance_1km_res (mg\u00b2/kg\u00b2)",
+    "trace_elements:Hg_concentration (\u00b5g/kg)",
+    "trace_elements:Hg_concentration_1km_res (mg/kg)",
+    "trace_elements:Hg_concentration_5km_res (mg/kg)",
+    "trace_elements:Hg_concentration_variance_1km_res (mg\u00b2/kg\u00b2)",
+    "trace_elements:Hg_residual (\u00b5g/kg)",
+    "trace_elements:Hg_stock (g ha\u207b\u00b9)",
+    "trace_elements:Mn_concentration_1km_res (mg/kg)",
+    "trace_elements:Mn_concentration_variance_1km_res (mg\u00b2/kg\u00b2)",
+    "trace_elements:Ni_concentration_1km_res (mg/kg)",
+    "trace_elements:Ni_concentration_5km_res (mg/kg)",
+    "trace_elements:Ni_concentration_variance_1km_res (mg\u00b2/kg\u00b2)",
+    "trace_elements:Pb_concentration_1km_res (mg/kg)",
+    "trace_elements:Pb_concentration_5km_res (mg/kg)",
+    "trace_elements:Pb_concentration_variance_1km_res (mg\u00b2/kg\u00b2)",
+    "trace_elements:Sb_concentration_1km_res (mg/kg)",
+    "trace_elements:Sb_concentration_variance_1km_res (mg\u00b2/kg\u00b2)",
+    "trace_elements:Zn_concentration (mg/kg)",
+    "trace_elements:Zn_concentration_5km_res (mg/kg)",
+    "trace_elements:Zn_concentration_5th_percentile (mg/kg)",
+    "trace_elements:Zn_concentration_95th_percentile (mg/kg)"
+  ]
+}
+```
+=========End of meta_column_names.json=========
+
+=========Start of meta_fused_datasets.json=========
+```json
+{
+  "3d-soil-hydraulic-database-europe-1-km-and-250-m-resolution": {
+    "title": "3D Soil Hydraulic Database of Europe at 1 km and 250 m resolution",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/3d-soil-hydraulic-database-europe-1-km-and-250-m-resolution",
+    "abstract": "A consistent spatial soil hydraulic database at 7 soil depths up to 2 m calculated for Europe based on SoilGrids250m and 1 km datasets and pedotransfer functions trained on the European Hydropedological Data Inventory. Saturated water content, water content at field capacity and wilting point, saturated hydraulic conductivity and Mualem-van Genuchten parameters for the description of the moisture retention, and unsaturated hydraulic conductivity curves have been predicted. The derived 3D soil hydraulic layers (EU-SoilHydroGrids ver1.0) can be used for environmental modelling purposes at catchment or continental scale in Europe. Currently, only EU-SoilHydroGrids provides information on the most frequently required soil hydraulic properties with full European coverage up to 2 m depth at 250 m resolution."
+  },
+  "arsenic-european-topsoils": {
+    "title": "Arsenic in European topsoils",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/arsenic-european-topsoils",
+    "abstract": "Maps of Arsenic (As) in EU topsoils at 250m resolution. In addition, we provide the exceedance probabilities for the threshold of 1.5, 20 and 45 mg kg-1 . We also provide comparison with GEMAS data on As."
+  },
+  "bacterial-fungal-biomass-fatty-acid-methyl-esters": {
+    "title": "Bacterial & fungal biomass (fatty acid methyl esters)",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/bacterial-fungal-biomass-fatty-acid-methyl-esters",
+    "abstract": "Land-use- and climate-mediated variations in soil bacterial and fungal biomass across Europe and their driving factors. These are data accompanying a study that was carried out by a number of researchers from various organizations, including staff from the European Commission Joint Research Centre"
+  },
+  "biodiversity-factor-soil-erosion": {
+    "title": "Biodiversity factor in soil erosion",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/biodiversity-factor-soil-erosion",
+    "abstract": "A biological factor to be included in soil erosion modelling. The available data for Earthwork diversity (richness and abundance) introduced a new \"earthworm factor\" to be incorporated in soil erosion modelling."
+  },
+  "cadmium-topsoils-european-union": {
+    "title": "Cadmium in topsoils of the European Union",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/cadmium-topsoils-european-union",
+    "abstract": "Cadmium content (mg kg-1) in the European Union topsoils applying an ensemble of machine learning models. The map of Cd distribution at a resolution of 100 m."
+  },
+  "caesium-137-and-plutonium-239240-european-topsoils": {
+    "title": "Caesium-137 and Plutonium-239+240 in European topsoils",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/caesium-137-and-plutonium-239240-european-topsoils",
+    "abstract": "Plutonium and Cesium inventories in European topsoils. Includes also the Chernobyl-derived 137Cs and Global-derived 137Cs"
+  },
+  "carbon-budget-eu-agricultural-soils": {
+    "title": "Carbon budget in the EU agricultural soils",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/carbon-budget-eu-agricultural-soils",
+    "abstract": "Cumulative C budget over the period 2016-20100 in the EU agricultural soils under the accelerated and current soil erosion scenarios."
+  },
+  "clay-mineral-inventory-soils-europe-based-lucas-2015-survey-soil-samples-2": {
+    "title": "Clay mineral inventory in soils of Europe based on LUCAS 2015 survey soil samples",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/clay-mineral-inventory-soils-europe-based-lucas-2015-survey-soil-samples-2",
+    "abstract": "These data are the input for the report \"Clay mineral inventory in soils of Europe based on LUCAS 2015 survey soil samples\" (2024). Clay minerals are a key factor in mineral soils as they are controlling physic, chemical and biological soil properties. The X-ray diffraction (XRD) analysis has been widely used to identify and quantify minerals in earth science The aim of the research reported is to describe the clay minerals in soils of Europe and United Kingdom by using soil samples from the Land Use/Cover Area Frame Survey (LUCAS) topsoil database sampled in 2015. A subset of 388 soil samples were selected from LUCAS 2015 topsoil survey."
+  },
+  "copper-distribution-topsoils": {
+    "title": "Copper distribution in topsoils in the European Union",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/copper-distribution-topsoils",
+    "abstract": "Copper distribution in European Union topsoils based on LUCAS points. The data are at 500m resolution and have been the result of advanced interpolation modelling."
+  },
+  "cover-crops-accross-europe": {
+    "title": "Cover Crops across Europe",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/cover-crops-accross-europe",
+    "abstract": "Disaggregated map of cover crops occurrence for Europe and the United Kingdom. Using a disaggregation model, we combined satellite data (Sentinel-1) with aggregated survey data to generate a high-resolution map (100m) of cover crops for Europe and the United Kingdom for the reference year of 2016."
+  },
+  "cover-management-factor-c-factor-eu": {
+    "title": "Cover Management factor (C-factor) for the EU",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/cover-management-factor-c-factor-eu",
+    "abstract": "This dataset (GIS map) (2015) represents the Cover Management factor (C-factor), one of the  input layers when calculating the Universal Soil Loss Equation (USLE) model, which is the most frequently used model for soil erosion risk estimation; for EU28; resolution 100m. The C-factor was estimated for a) arable lands based on crop composition and for b) all other land uses (non-arable) based on the vegetation density and land cover type. The management practices (reduced tillage/no till, plant residues and winter cover crops) were taken into account in estimating C-factor in arable lands."
+  },
+  "estimate-net-erosion-and-sediment-transport-using-watemsedem-european-union": {
+    "title": "Net erosion and sediment transport using WaTEM/SEDEM (for EU)",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/estimate-net-erosion-and-sediment-transport-using-watemsedem-european-union",
+    "abstract": "Dataset (GIS map) (218) that shows the net soil erosion and deposition in European Union as a result of an application WaTEM/SEDEM model; resolution 100m; EU28. Data are also available at 25m resolution and at catchment scale."
+  },
+  "european-food-safety-authority-efsa-data-persam-software-tool": {
+    "title": "European Food Safety Authority (EFSA) Data & PERSAM software tool",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/european-food-safety-authority-efsa-data-persam-software-tool",
+    "abstract": "Data and software made public as the result of a collaboration between JRC and EFSA. It contains soil, weather and crop data collected by JRC and organised by EFSA for its purpose. The site also hosts the software tool PERSAM for Predicting Environmental Concentrations in soil in support of the: \"EFSA Guidance Document for predicting environmental concentrations of active substances of plant protection products and transformation products of these active substances in soil\" which EFSA was asked by the European Commission to prepare. The data/maps are provided as rasters (ASCII grid). The soil data are: Topsoil Organic Matter content, Topsoil pH water, Topsoil Bulk Density, Topsoil Texture Class, Topsoil Water Content at Field Capacity."
+  },
+  "european-hydropedological-data-inventory-eu-hydi-database-0": {
+    "title": "European Hydropedological Data Inventory (EU-HYDI) database",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/european-hydropedological-data-inventory-eu-hydi-database-0",
+    "abstract": "The European Hydropedological Data Inventory (EU-HYDI) contains soil properties with a special focus on hydrological properties. It also includes various other measured soil characteristics associated to the same samples. It can hence serve multiple purposes, including scientific research, modelling and application of models at different geographical scales. The dataset consists of 10 interlinked CSV files."
+  },
+  "european-map-soil-suitability-provide-platform-most-human-activities-eu28": {
+    "title": "European map of soil suitability to provide a platform for most human activities (EU28)",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/european-map-soil-suitability-provide-platform-most-human-activities-eu28",
+    "abstract": "This dataset (map)(2016) presents the suitability of soil as a platform for most human activities in the EU. Calculation of suitability was done using vaious properties of the European Soil database (soil type, soil water regime, limitation to agricultural use, depth to rock, land use) and slope of the terrain."
+  },
+  "european-soil-database-derived-data": {
+    "title": "European Soil Database Derived data",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/european-soil-database-derived-data",
+    "abstract": "A number of layers for soil properties have been created based on data from the European Soil Database in combination with data from the Harmonized World Soil Database (HWSD) and Soil-Terrain Database (SOTER)."
+  },
+  "european-soil-database-v2-raster-library-1kmx1km": {
+    "title": "European Soil Database v2 Raster Library 1kmx1km",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/european-soil-database-v2-raster-library-1kmx1km",
+    "abstract": "This database (2024) is a new set of raster data (GeoTIFF) that have been derived from the European soil Database v2, for most attributes. The values for the attributes are categorized (non-continuous). These rasters are an interpretation of the data that are contained in the ESDB v2.0."
+  },
+  "global-rainfall-erosivity": {
+    "title": "Global Rainfall Erosivity",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/global-rainfall-erosivity",
+    "abstract": "Rainfall erosivity dataset  (2017) is one of the input layers when calculating the Revised Universal Soil Loss Equation (RUSLE) model, which is the most frequently used model for soil erosion risk estimation; for the whole World; R-factor map at resolutions of 30 arc-sec ((~1 km at the Equator)."
+  },
+  "global-soil-erodibility": {
+    "title": "Global Soil Erodibility",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/global-soil-erodibility",
+    "abstract": "This dataset encompasses global soil erodibility (K) factor maps, with the K factor being estimated through the Wischmeier and Smith (1978) method. In addition, measured values of saturated  hydraulic conductivity (Ksat) have been incorporated into the original method to formulate the Ksat-based soil erodibility (Kksat factor) map. A third k-factor dataset which was included in the GloSEM (Borrelli et al., 2017) is also included."
+  },
+  "global-soil-organic-carbon-estimates": {
+    "title": "Global Soil Organic Carbon Estimates",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/global-soil-organic-carbon-estimates",
+    "abstract": "Global estimates of soil organic carbon stocks have been produced in the past to support the calculation of potential emissions of CO2 from the soil under scenarios of change land use/cover and climatic conditions."
+  },
+  "glosem": {
+    "title": "High resolution cropland global soil erosion (GloSEM 1.3)",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/glosem",
+    "abstract": "Global Soil Erosion Modelling (GloSEM) platform containts 4 datasets on global soil erosion in arable lands (at 100m resolution): Baseline data (2019), soil loss in 2070 for three climatic scenarios RCP2.6, RCP4.5, RCP8.5"
+  },
+  "gully-erosion-based-lucas": {
+    "title": "Gully Erosion based on LUCAS",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/gully-erosion-based-lucas",
+    "abstract": "The LUCAS topsoil survey 2018 included a module for visual assessment of gully erosion. Gully erosion channels were detected in 1% of the visited LUCAS topsoil sites. Find the 211 points declared as gully erosion."
+  },
+  "heavy-metals-topsoils": {
+    "title": "Heavy Metals in topsoils",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/heavy-metals-topsoils",
+    "abstract": "GIS Maps (2008) produced by mapping the concentrations of eight critical heavy metals (arsenic, cadmium, chromium, copper, mercury, nickel, lead and zinc) using the 1588 georeferenced topsoil samples from the FOREGS Geochemical database. The concentrations were interpolated using block regression-kriging over the 26 European countries that contributed to the database."
+  },
+  "land-degradation-europe": {
+    "title": "Land Degradation in Europe",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/land-degradation-europe",
+    "abstract": "This dataset includes the Land Multi-degradation Index (LMI) for arable and agricultural lands and data for 12 indicators (land degradation processes) which were compiled to develop the LMI. The dataset includes the agricultural (~2 million km2) and the arable (~1.1 million km2) lands of the EU and other European countries."
+  },
+  "land-suitability-temperate-europe": {
+    "title": "Land suitability in temperate Europe",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/land-suitability-temperate-europe",
+    "abstract": "This datasets includes land suitability maps for several crops and land uses (14 crops , 7 fruit trees, 3 land-use types)  in the temperate continental climate of Europe. To model the land suitability we used geospatial data depicting seventeen eco-pedological indicators (e.g. soil texture, pH, porosity, temperature, precipitation, slope). To evaluate how the land is utilized, the suitability maps have been spatially cross-tabulated with a crop map."
+  },
+  "ls-factor-slope-length-and-steepness-factor-eu": {
+    "title": "LS-factor (Slope Length and Steepness factor) for the EU",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/ls-factor-slope-length-and-steepness-factor-eu",
+    "abstract": "This dataset (GIS maps) (2015) represents the \"Slope Length and Steepness factor\" (LS-factor), one of the six input layers when calculating the Universal Soil Loss Equation (USLE) model, which is the most frequently used model for soil erosion risk estimation; for EU28; maps at resolutions of 25m (per country) and 100m (Europe-wide)."
+  },
+  "lucas-2009-topsoil-data": {
+    "title": "LUCAS 2009 TOPSOIL data",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/lucas-2009-topsoil-data",
+    "abstract": "Data from the 2009 LUCAS campaign soil component containing soil properties data (clay, silt and sand content, coarse fragments, pH, organic carbon content, CaCO3, nitrogen, phosphorous, potassium, cation exchane capacity) and multispectral absorbance data."
+  },
+  "lucas-2015-topsoil-data-switzerland": {
+    "title": "LUCAS 2015 Topsoil data of Switzerland",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/lucas-2015-topsoil-data-switzerland",
+    "abstract": "The dataset contains the data of physical and chemical properties analysed in samples taken in Switzerland within the context of LUCAS 2015 survey. These data have been used in the study “Comparison of sampling with a spade and gouge auger for topsoil monitoring at the continental scale”, published in the European Journal of Soil Science (https://onlinelibrary.wiley.com/doi/abs/10.1111/ejss.12862). The dataset format is an Excel file."
+  },
+  "lucas-2018-topsoil-data": {
+    "title": "LUCAS 2018 TOPSOIL data",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/lucas-2018-topsoil-data",
+    "abstract": "Data from the 2018 LUCAS campaign soil component containing soil properties data for 18,984 samples: pH (CaCl2 and H2O), organic carbon content, CaCO3, nitrogen, phosphorous, potassium, EC (Electrical conductivity), Oxalate extractable Fe and Al ."
+  },
+  "lucas2015-topsoil-data": {
+    "title": "LUCAS 2015 TOPSOIL data",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/lucas2015-topsoil-data",
+    "abstract": "Data from the 2015 LUCAS campaign soil component containing soil properties data (clay, silt and sand content, coarse fragments, pH (CaCl2 and H2O), organic carbon content, CaCO3, nitrogen, phosphorous, potassium, EC (Electrical conductivity) and multispectral reflectance data for 21,859 samples. These primary data are supplemented by reference ancillary data describing a range of environmental conditions for the LUCAS Soil locations."
+  },
+  "map-indicating-availability-raw-material-soils-european-union-organic-soil-material-b-soil": {
+    "title": "Maps indicating the availability of Raw Material from soils in the European Union",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/map-indicating-availability-raw-material-soils-european-union-organic-soil-material-b-soil",
+    "abstract": "This dataset (maps)(2016) indicates the availability of Raw Material (organic soil material and soil material for constructions) from soils in the European Union."
+  },
+  "maps-heavy-metals-soils-eu-based-lucas-2009-hm-data-0": {
+    "title": "Maps of heavy metals in the soils of the EU, based on LUCAS 2009 HM data",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/maps-heavy-metals-soils-eu-based-lucas-2009-hm-data-0",
+    "abstract": "Detailed maps of heavy metals in the EU27 (EU-28 except Croatia), based on topsoil HM data from LUCAS 2009"
+  },
+  "maps-indicators-soil-hydraulic-properties-europe": {
+    "title": "Maps of indicators of soil hydraulic properties for Europe",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/maps-indicators-soil-hydraulic-properties-europe",
+    "abstract": "Soil hydraulic properties maps (2016) for Europe: for Water retention of topsoil:  saturated water content (cm3/cm3), water content at  field capacity (cm3/cm3), water content at wilting point (cm3/cm3); for Hydraulic conductivity of topsoil: saturated hydraulic conductivity (cm/day). Besides the true values in the units mentioned  values scaled between 1 and 10 without measurement units were also calculated."
+  },
+  "maps-related-predicting-preservation-cultural-artefacts-and-buried-materials-soils-eu-0": {
+    "title": "Maps of preservation capacity of cultural artefacts and buried materials in soils in the EU",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/maps-related-predicting-preservation-cultural-artefacts-and-buried-materials-soils-eu-0",
+    "abstract": "Maps (2016) that indicate the preservation capacity of cultural artefacts and buried materials in soils in the EU, for bones, teeth and shells (bones), organic materials (organics), metals (Cu, bronze and Fe) (metals), stratigraphic evidence (strati)."
+  },
+  "maps-storing-and-filtering-capacity-soils-europe": {
+    "title": "Maps of the Storing and Filtering Capacity of Soils in Europe",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/maps-storing-and-filtering-capacity-soils-europe",
+    "abstract": "This dataset (2016) contains 10 maps that relate to the soil's storing and filtering capacity in Europe (the EU only): cation storing capacity (STOR_CAPCA), cation filtering capacity (FILT_CAPCA), anion storing capacity (STOR_CAPAN), anion filtering capacity (FILT_CAPAN), solids and pathogenic microorganisms storing capacity (STOR_CAPSO), solids and pathogenic microorganisms filtering capacity (FILT_CAPSO), non-polar organic chemicals storing capacity (STOR_CAPNP), non-polar organic chemicals filtering capacity (FILT_CAPNP), nonaqueous Phase Liquids (NAPL) storing capacity (STOR_NAPL), nonaqueous Phase Liquids (NAPL),  filtering capacity (FILT_NAPL). As input, variables from the European Soil Database have been used."
+  },
+  "mercury-content-european-union-topsoil": {
+    "title": "Mercury content in the European Union topsoil",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/mercury-content-european-union-topsoil",
+    "abstract": "Topsoil Hg concentrations (μg kg−1) across 26 EU countries estimated by deep neural network – regression kriging. We also provide Mercury stocks and mercury fluxes to main riverbasins and sea outlets. The assessment is based on 21591 LUCAS samples (0-20cm) from 26 European Union countries."
+  },
+  "multiple-concurrent-soil-erosion-processes": {
+    "title": "Multiple concurrent soil erosion processes",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/multiple-concurrent-soil-erosion-processes",
+    "abstract": "A first-ever assessment at European scale combines the threat of water, wind, tillage and harvesting to reveal the cumulative impact on arable land. We present the datasets for each of the erosion process (water, wind, tillage, harvesting root crops) and their cumulative effect at 100m resolution for EU arable lands (110 Million ha)."
+  },
+  "n2o-emissions-agricultural-soils-europe": {
+    "title": "N2O emissions from agricultural soils in Europe",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/n2o-emissions-agricultural-soils-europe",
+    "abstract": "This dataset derives from the integration of the LUCAS soil survey with the bio-geochemistry process-based model DayCent. The model was ran for more than 11,000 LUCAS sampling points under agricultural use, assessing also the model uncertainty. Meta-models based on model outcomes and the Random Forest algorithm were used to upscale the N2O emissions at 1km resolution."
+  },
+  "natural-susceptibility-soil-compaction-europe": {
+    "title": "Natural susceptibility to soil compaction in Europe",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/natural-susceptibility-soil-compaction-europe",
+    "abstract": "Map (2008) showing the natural susceptibility of agricultural soils to compaction if they were to be exposed to compaction, based on the creation of logical connections between relevant parameters (using pedotransfer rules), taking as input parameters  attributes of the European soil database (soil type, texture, etc.). For EU-27."
+  },
+  "observedtypical-soc-index": {
+    "title": "Observed/typical SOC index",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/observedtypical-soc-index",
+    "abstract": "Observed/typical Soil Organic Carbon (SOC) index classes and associated pedo-climate zones across the EU and UK are presented in 2 GeoTiff files at 100 m resolution."
+  },
+  "octop-topsoil-organic-carbon-content-europe": {
+    "title": "OCTOP: Topsoil Organic Carbon Content for Europe",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/octop-topsoil-organic-carbon-content-europe",
+    "abstract": "A 2004 GIS map of Soil Organic Carbon (SOC) content (%) in the surface horizon of soils in Europe, associated to a JRC internal report."
+  },
+  "pan-european-soc-stock-agricultural-soils": {
+    "title": "Pan-European SOC stock of agricultural soils",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/pan-european-soc-stock-agricultural-soils",
+    "abstract": "Data (2014) related to Pan-European SOC stock of agricultural soils, containing GIS maps for a) Pan-European SOC stock of agricultural soils (shapefile),  b) Potential carbon sequestration by modelling a comprehensive set of management practices (shapefile),  c) Average Eroded SOC in agricultural soils (raster)."
+  },
+  "pan-european-soil-erosion-risk-assessment-pesera": {
+    "title": "Pan European Soil Erosion Risk Assessment - PESERA",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/pan-european-soil-erosion-risk-assessment-pesera",
+    "abstract": "A 2003 GIS map of Soil erosion estimates (t/ha/yr) by applying the PESERA GRID (physical) model at 1km, using the European Soil Database, CORINE land cover, climate data from the MARS Project and a Digital Elevation Model. The resulting estimates of sediment loss are from erosion by water."
+  },
+  "phosphorus-budget-and-p-stocks": {
+    "title": "Phosphorus budget and P stocks",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/phosphorus-budget-and-p-stocks",
+    "abstract": "Phosphorus (P) budget in the European agricultural soils. We provide shape files with main inputs (fertilizers, manure, chemical weathering, atmospheric deposition) and the losses by water erosion. In addition, we model the Total P and the relevant P stocks (available/Olsen, Total). We also make available 21,681 LUCAS point data with measured Total P."
+  },
+  "phosphorus-cycle-european-agricultural-soils": {
+    "title": "Phosphorus cycle in European agricultural soils",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/phosphorus-cycle-european-agricultural-soils",
+    "abstract": "Process-based biogeochemical models are valuable instruments to monitor the P cycle and predict the effect of agricultural management policies. We upscale the calibrated DayCent model at European level using data-derived soil properties, advanced input data sets, and representative management practices. Available datasets include Current P Budget and Soil Pools, Projected P Budget and Soil Pools for the EU and UK as well the datasets corresponding to the figures of the related manuscript."
+  },
+  "potential-threats-soil-biodiversity-europe": {
+    "title": "Potential threats to soil biodiversity in Europe",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/potential-threats-soil-biodiversity-europe",
+    "abstract": "Dataset that contains 3 GIS maps showing Potential threats to soil biodiversity in Europe (for soil microorganisms, for fauna,forbiological functions), along with 13 input layers (habitat fragmentation, climate change, soil erosion, etc.); resolution 500m."
+  },
+  "priming-effects-soils-across-europe": {
+    "title": "Glucose-induced priming effects in soils across Europe",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/priming-effects-soils-across-europe",
+    "abstract": "Quantification and comparison of glucose-induced priming effects in soils with contrasting land uses and under different crop types"
+  },
+  "rainfall-erosivity-european-union-and-switzerland": {
+    "title": "Rainfall Erosivity in the EU and Switzerland (R-factor)",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/rainfall-erosivity-european-union-and-switzerland",
+    "abstract": "Dataset (GIS map) (2015) and associated products for the \"Rainfall erosivity\" (R-factor), one of the input layers when calculating the Universal Soil Loss Equation (USLE) model, which is the most frequently used model for soil erosion risk estimation; for EU28+Switzerland; R-factor map at resolutions of 500m. Users can downloads Raw data, Baseline map (2010), Monthly erosivity, Future projections (2050), Past erosivity (1961-2000)."
+  },
+  "SOC-changes-2009-18": {
+    "title": "Changes in Soil Organic Carbon in Croplands and Grasslands between 2009 and 2018",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/SOC-changes-2009-18",
+    "abstract": "This dataset (map) illustrates the variations in soil organic carbon (measured in g C kg y-1) within the 0-20 cm depth range for croplands and grasslands across the EU and UK between 2009 and 2018."
+  },
+  "soil-biomass-productivity-maps-grasslands-and-pasture-coplands-and-forest-areas-european": {
+    "title": "Soil Biomass Productivity maps of grasslands and pasture, of croplands and of forest areas in the European Union (EU27)",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/soil-biomass-productivity-maps-grasslands-and-pasture-coplands-and-forest-areas-european",
+    "abstract": "This dataset consists of 3 GIS maps that indicate the soil biomass productivity of grasslands and pasture, of croplands and of forest areas in the European Union (EU27)"
+  },
+  "soil-bulk-density-europe": {
+    "title": "Soil Bulk Density in Europe",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/soil-bulk-density-europe",
+    "abstract": "This dataset includes bulk density for Europe in 0-20cm, 0-10cm, 10-20cm layers generated with advanced Cubist rule-based regression model. We also provide the Packing density estimation based on bulk density and clay content. In addition, we make available the point data measurements of bulk density"
+  },
+  "soil-carbon-risk-index": {
+    "title": "Soil Carbon Risk Index",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/soil-carbon-risk-index",
+    "abstract": "This dataset includes the a) Soil organic carbon risk index b) SOC fractions predicted by visible near-infrared c) the mineral-associated organic carbon (MAOC) saturation.This repository accompanies the publication \"Revisiting the soil carbon saturation concept to inform a risk index in European agricultural soils\" and can be used to access the results and code."
+  },
+  "soil-degradation-indicators-eu": {
+    "title": "Soil degradation indicators in EU",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/soil-degradation-indicators-eu",
+    "abstract": "Pan-EU assessment of soil degradation based on the latest state-of-the-art indicators of soil degradation as demonstrated in the EU Soil Health Dashboard. This dataset includes the 19 Soil degradation indicators plus the sum of all processes."
+  },
+  "soil-erodibility-k-factor-high-resolution-dataset-europe": {
+    "title": "Soil Erodibility (K- Factor) High Resolution dataset for Europe",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/soil-erodibility-k-factor-high-resolution-dataset-europe",
+    "abstract": "Map at 500m resolution (2014) providing a complete picture of the soil erodibility in the European Union member states. It is derived on the basis of the LUCAS 2009 soil survey exercise and the European Soil Database."
+  },
+  "soil-erosion-forestland-europe-using-rusle2015": {
+    "title": "Soil erosion in forestland in Europe (using RUSLE2015)",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/soil-erosion-forestland-europe-using-rusle2015",
+    "abstract": "Dataset (2 GIS-maps) (2016) related to soil erosion in Forestland in Europe. One map is the soil loss potential for EU28; the other map is the European Forest Cover Change for 36 European countries."
+  },
+  "soil-erosion-water-rusle2015": {
+    "title": "Soil erosion by water (RUSLE2015)",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/soil-erosion-water-rusle2015",
+    "abstract": "Dataset (GIS map) (2015) that shows the Soil Loss by Water Erosion in Europe and is the result of applying a modified version of the Revised Universal Soil Loss Equation (RUSLE) model, RUSLE 2015; resolution 100m. EU28. Two data points are available: 2010 and 2016"
+  },
+  "soil-function-data-measured-lucas-2018-sites-across-eu": {
+    "title": "Soil function data measured in LUCAS 2018 sites across the EU",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/soil-function-data-measured-lucas-2018-sites-across-eu",
+    "abstract": "In the LUCAS 2018 survey, soil functions have been measured in the 881 sampling sites selected for the soil biodiversity assessment across Europe. These soil functions include * soil aggregates (i.e., mean width diameter and water-stable aggregates), * enzyme activities, * microbial respiration and biomass, and * measurement of ester-linked fatty acid methyl esters (FAMEs)."
+  },
+  "soil-ghg-fluxes-using-lucas-soil-daycent": {
+    "title": "Soil GHG fluxes using LUCAS soil-DayCent (for EU)",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/soil-ghg-fluxes-using-lucas-soil-daycent",
+    "abstract": "Soil fluxes (CO2 and N2O ) under mitigation scenarios using the LUCAS soil-DayCent model integration framework"
+  },
+  "soil-loss-due-crop-harvesting-european-union": {
+    "title": "Soil loss due to crop harvesting in the European Union",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/soil-loss-due-crop-harvesting-european-union",
+    "abstract": "Soil loss due to crop harvesting in the European Union. The regional estimates of total Soil Loss by Crop Harvesting (SLCH) are presented at country and regional level."
+  },
+  "soil-microbial-biomass-and-respiration": {
+    "title": "Soil microbial biomass and respiration",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/soil-microbial-biomass-and-respiration",
+    "abstract": "Maps of potential soil microbial basal respiration (bas), microbial biomass (Cmic), and respiratory quotient (qO2) predicted across Europe. Monthly maps for bas and Cmic are also available"
+  },
+  "soil-organic-carbon-saturation-capacity": {
+    "title": "Soil Organic Carbon - Saturation Capacity in Europe",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/soil-organic-carbon-saturation-capacity",
+    "abstract": "This dataset (map) (2016) shows the Soil Organic Carbon (SOC) saturation capacity, expressed as the ratio between the actual and the potential SOC stock in each pixel. Values close to 0 indicate a great potential of soil to store more carbon."
+  },
+  "soil-organic-matter-som-fractions": {
+    "title": "Soil Organic Matter (SOM) fractions",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/soil-organic-matter-som-fractions",
+    "abstract": "This dataset contains the original measured Soil Organic Matter (SOM) fractions of a subset of the LUCAS 2009 topsoil dataset. This dataset includes 352 samples for all land uses and 186 samples only for grassland and fores used to derived maps on Particulate Organic Matter (POM) and Mineral-Associated Organic Matter (MAOM)"
+  },
+  "Soil_erosion_by_wind": {
+    "title": "Soil erosion by wind",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/Soil_erosion_by_wind",
+    "abstract": "This dataset consists of various elements related to soil erosion by wind: 1) Soil loss by wind erosion in European agricultural soils (2016); 1km resolution, 2)  Land susceptibility to wind erosion (2014), 500m resolution, 3) Wind erosion susceptibility of European soils (2014); 500m resolutiomn, and 4) Agriculture Field Parameters data (containing averaged Field Size, Field Orientation, Field Length, Average Number of Images, Percentage of Large Fields and Length to Width Ratios) for the EU 27 Member states and Switzerland, aggregated to NUTS region."
+  },
+  "spadem": {
+    "title": "SPADE/M",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/spadem",
+    "abstract": "Database (2004) developed from the measured profiles; present in the Soil Profile Analytical Database of Europe of the European Soil Database v2. It counts 560 profiles within the EU."
+  },
+  "support-practices-factor-p-factor-eu": {
+    "title": "Support Practices factor (P-factor) for the EU",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/support-practices-factor-p-factor-eu",
+    "abstract": "This GIS map (2015) represents the \"Support Practices factor\" (P-factor) for the EU. At European level, the effect of support practices (compulsory for farmers to receive incentives under the CAP-GAEC) on soil loss were assessed by P-factor estimation taking into account a) contour farming b) maintenance of stone walls and c) grass margins. Resolution 1km."
+  },
+  "topsoil-soil-organic-carbon-lucas-eu25": {
+    "title": "Topsoil Soil Organic Carbon (LUCAS) for EU25",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/topsoil-soil-organic-carbon-lucas-eu25",
+    "abstract": "This dataset (2015) provides maps for Topsoil Soil Organic Carbon in EU-25 that are based on LUCAS 2009 soil poibnt data through a generalized additive model. Map of predicted topsoil organic carbon content (g C kg-1) : The map of predicted topsoil organic carbon content (g C kg-1) was produced by fitting a generalised additive model between organic carbon measurements from the LUCAS survey (dependent variable) and a set of selected environmental covariates; namely slope, land cover, annual accumulated temperature, net primary productivity, latitude and longitude. It also includes a Map of standard error of the OC model predictions (g C kg-1)."
+  },
+  "un-sustainable-development-goal-1531-assessment-land-degradation-indicator-eu-scale": {
+    "title": "UN Sustainable Development Goal  15.3.1: Assessment of the land degradation indicator at EU scale",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/un-sustainable-development-goal-1531-assessment-land-degradation-indicator-eu-scale",
+    "abstract": "This dataset covers 9 maps associated to the assessment of the land degradation indicator at EU scale in the context of the UN Sustainable Development Goal  15.3.1, and corresponding to the output reported in a peer-reviewed publication. The main map is the one that expresses land degradation on the basis of soil organic carbon and soil erosion values."
+  },
+  "zn-concentrations-eu-topsoils": {
+    "title": "Zinc concentrations in EU topsoils",
+    "dataset_url": "https://esdac.jrc.ec.europa.eu/content/zn-concentrations-eu-topsoils",
+    "abstract": "Zinc (Zn) is essential to sustain crop production and human health, while it can be toxic when present in excess. The Zn concentration (mg kg-1) in European topsoils as predicted by the quantile regression forest using the 21,682 samples of LUCAS. The resolution of this map is 250 m by 250 m."
+  }
+}
+```
+=========End of meta_fused_datasets.json=========
+

gpt_resources/prompt.md

@@ -0,0 +1,207 @@
+You are **ERP-GPT-EU**, an expert AI assistant for querying, analyzing, and interpreting high-resolution soil data across Europe.
+
+Your behavior, data access, and tool usage are governed by two authoritative knowledge bases:
+
+- **`knowledge_dataset.md`** — defines the LUCAS-MEGA fused dataset, including its origin, scale, structure, properties, metadata, and terminology.
+- **`knowledge_api.md`** — defines the geographic resolution and soil data-retrieval APIs, including recommended usage patterns and sequencing.
+
+These documents are **authoritative**.
+Do not invent new dataset fields, APIs, or dataset semantics.
+If requested information is not present in the dataset or APIs, state this explicitly.
+
+Your users include scientists, agronomists, land managers, policy makers, and data analysts.
+Your responses must be scientifically accurate, explicit about uncertainty, and clearly structured.
+
+---
+
+## 🔧 Technical Specifications
+
+### 1. Session Handling
+- At the start of each conversation, silently generate a random ASCII-only session name
+  (UUID-like, no spaces; e.g. `soil-gpt-session-h3k92fa7`).
+- Use the same session name for **all tool calls** in the conversation so that generated map files remain isolated per user.
+- The session name is **internal only** and must never be revealed or mentioned.
+
+---
+
+### 2. Dataset Awareness & Scientific Reasoning
+- You have structured access to the **LUCAS-MEGA** dataset, comprising:
+  - tens of thousands of soil samples (rows),
+  - up to ~1,000 soil and ecosystem properties (columns).
+- You may explain soil science concepts using general scientific knowledge.
+- **All numerical values, statistics, sample attributes, or maps must be retrieved via the APIs**, never inferred from memory or assumption.
+- Dataset metadata provides context (e.g. sources, uncertainty, missingness) but does not replace data retrieval.
+- When scientific interpretation is uncertain, rely on widely accepted, non-speculative knowledge.
+
+---
+
+### 3. API-Driven Data Access
+- All **authoritative geographic resolution** and **soil data access** must use the APIs defined in `knowledge_api.md`, including:
+  - resolving place names or coordinates to GADM regions,
+  - retrieving point-based (sample-level) soil properties,
+  - generating spatial property maps.
+- Never simulate, fabricate, or bypass an API when retrieving data.
+- If requested data does not exist in the dataset, say so clearly.
+- **[Very Important]** You must infer the most relevant soil property names from user input. For example, if the user asks for soil texture, you should use these properties:
+  - clay_percentage
+  - silt_percentage
+  - sand_percentage
+  - coarse_percentage
+
+The full property list is given in Knowledge (`meta_column_names.json`). The following are selected ones that are more likely to be requested than others:
+
+```json
+{
+  "properties": [
+    "photos",
+    "climate_change_pressure_index",
+    "genetically_modified_organism_use_pressure_index",
+    "habitat_fragmentation_pressure_index",
+    "industrial_pollution_pressure_index",
+    "intensive_human_exploitation_pressure_index",
+    "land_use_change_pressure_index",
+    "organic_matter_decline_pressure_index",
+    "radioactivity_pressure_index",
+    "soil_biological_functions_threat_index",
+    "soil_compaction_pressure_index",
+    "soil_erosion_pressure_index",
+    "soil_fauna_threat_index",
+    "soil_microorganisms_threat_index",
+    "soil_salinity_pressure_index",
+    "basal_respiration_general",
+    "basal_respiration_landcover",
+    "microbial_biomass_general",
+    "microbial_biomass_landcover",
+    "respiratory_quotient_general",
+    "respiratory_quotient_landcover",
+    "soil_biomass_productivity_cropland",
+    "CaCO3_content",
+    "SOC_saturation_ratio",
+    "eroded_carbon_stock",
+    "eroded_soc_content",
+    "estimated_organic_carbon_density_subsoil",
+    "estimated_organic_carbon_density_topsoil",
+    "observed_vs_typical_soc_index",
+    "observed_vs_typical_soc_index_confidence_zone",
+    "organic_carbon_content",
+    "organic_carbon_content_subsoil_ESDB",
+    "organic_carbon_content_topsoil",
+    "organic_carbon_content_topsoil_ESDB",
+    "soc_change_2009_2018",
+    "topsoil_OC_prediction_mean",
+    "topsoil_OC_prediction_std",
+    "electrical_conductivity",
+    "pH_in_CaCl2",
+    "pH_in_H2O",
+    "pH_in_H2O_EFSA",
+    "annual_precipitation",
+    "annual_temperature",
+    "cover_crop_fraction_5th_percentile",
+    "cover_crop_fraction_95th_percentile",
+    "cover_crop_fraction_median",
+    "cover_crop_fraction_std",
+    "durum_wheat_fraction",
+    "effective_rooting_depth",
+    "fallow_fraction",
+    "ls_factor_slope_length_and_steepness",
+    "net_erosion_rate_PESERA",
+    "net_erosion_rate_WaTEM_SEDEM",
+    "soil_displacement_estimate",
+    "soil_loss_by_water",
+    "K_extractable",
+    "N_extractable",
+    "P_available_stock",
+    "P_extractable",
+    "P_total_concentration_topsoil",
+    "P_total_stock_topsoil",
+    "field_capacity_water_content",
+    "field_capacity_water_content_EFSA",
+    "saturated_hydraulic_conductivity",
+    "saturated_water_content",
+    "topographic_wetness_index",
+    "total_available_water_capacity_subsoil_ESDB",
+    "total_available_water_capacity_subsoil_SMU_ESDB",
+    "total_available_water_capacity_topsoil_ESDB",
+    "total_available_water_capacity_topsoil_SMU_ESDB",
+    "wilting_point_water_content",
+    "aridity_index_mean_cropland",
+    "land_multi_degradation_index_agricultural_lands",
+    "soil_erosion_exceeding_10Mg_ha_yr",
+    "nighttime_light_intensity",
+    "solar_radiation_input",
+    "bulk_density",
+    "bulk_density_0_10cm",
+    "bulk_density_10_20cm",
+    "bulk_density_subsoil_ESDB",
+    "bulk_density_topsoil_EFSA",
+    "bulk_density_topsoil_ESDB",
+    "packing_density",
+    "organic_matter_content",
+    "clay_percentage",
+    "clay_percentage_subsoil_ESDB",
+    "clay_percentage_topsoil_ESDB",
+    "coarse_percentage",
+    "coarse_percentage_subsoil_ESDB",
+    "coarse_percentage_topsoil_ESDB",
+    "sand_percentage",
+    "sand_percentage_subsoil_ESDB",
+    "sand_percentage_topsoil_ESDB",
+    "silt_percentage",
+    "silt_percentage_subsoil_ESDB",
+    "silt_percentage_topsoil_ESDB",
+    "digital_elevation_model",
+    "elevation",
+    "slope",
+    "As_concentration_1km_res",
+    "Cd_concentration",
+    "Co_concentration_1km_res",
+    "Cr_concentration_variance_1km_res",
+    "Cu_concentration",
+    "Hg_concentration",
+    "Hg_residual",
+    "Hg_stock",
+    "Mn_concentration_1km_res",
+    "Pb_concentration_1km_res",
+    "Sb_concentration_1km_res",
+    "Zn_concentration"
+  ]
+}
+```
+
+**[Critical Instruction]**
+
+If any API response includes direct image URLs (e.g., `.png`, `.jpg`, `.jpeg`, `.webp`), you must output each image URL **exactly as plain text** in the chat immediately after receiving it.
+
+Do **not** wrap the URL in Markdown links:
+
+✅ Correct:
+https://example.com/image.png
+
+❌ Incorrect:
+[View Image](https://example.com/image.png)
+![img](https://example.com/image.png)
+
+---
+
+## 🧠 Scientific Assistant Role
+
+You are not merely an API interface.
+
+Your role includes:
+- interpreting retrieved soil data,
+- explaining uncertainty, spatial scale, and data limitations,
+- comparing properties, regions, or scenarios when appropriate,
+- synthesizing insights across multiple soil attributes,
+- helping users understand **what the data implies**, not just what it returns.
+
+Always distinguish clearly between:
+- **observed data** (retrieved values),
+- **metadata-based context** (sources, uncertainty, coverage),
+- and **scientific interpretation**.
+
+**Maintain the big picture**:
+soil data gains value only when it is **contextualized, qualified, and communicated clearly**.
+
+**Author**
+Dr. Kuangdai Leng
+Earth Rover Program (ERP)

gpt_resources/schema.json

@@ -0,0 +1,698 @@
+{
+  "openapi": "3.1.1",
+  "info": {
+    "title": "ERP-GPT-Europe Tool API",
+    "version": "1.0.0"
+  },
+  "servers": [
+    {
+      "url": "https://api.erp-soilgpt.uk/"
+    }
+  ],
+  "paths": {
+    "/resolve_place": {
+      "post": {
+        "summary": "Resolve a place name to coordinates, bounding box, and GADM region",
+        "description": "Use this tool to resolve a place name or fallback country into coordinates, bounding box, and GADM ID using Nominatim and hierarchical region matching. Useful as the first step before spatial or soil queries.",
+        "operationId": "resolve_place",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "place_name": {
+                    "type": "string",
+                    "description": "The name of the place to resolve, such as 'Kisumu' or 'Lake Victoria'."
+                  },
+                  "fallback": {
+                    "type": "string",
+                    "description": "Optional fallback country to help disambiguate the place, e.g., 'Kenya'."
+                  },
+                  "session_name": {
+                    "type": "string",
+                    "description": "A required session identifier (random, internal) to ensure output file isolation."
+                  }
+                },
+                "required": [
+                  "place_name",
+                  "session_name"
+                ]
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Successful place resolution with coordinates, bounding box, and GADM region",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "status": {
+                      "type": "string",
+                      "description": "Text message describing the result or fallback used"
+                    },
+                    "used_name": {
+                      "type": [
+                        "string",
+                        "null"
+                      ],
+                      "description": "The actual query string used, possibly with fallback country appended"
+                    },
+                    "latitude": {
+                      "type": [
+                        "number",
+                        "null"
+                      ],
+                      "description": "Latitude in decimal degrees (WGS84)"
+                    },
+                    "longitude": {
+                      "type": [
+                        "number",
+                        "null"
+                      ],
+                      "description": "Longitude in decimal degrees (WGS84)"
+                    },
+                    "bbox_area": {
+                      "type": [
+                        "number",
+                        "null"
+                      ],
+                      "description": "Approximate area of the bounding box in square degrees"
+                    },
+                    "gid": {
+                      "type": [
+                        "string",
+                        "null"
+                      ],
+                      "description": "Best matching GADM ID (e.g., 'KEN.1.3_1') or null if not found"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/gadm/find_gid": {
+      "post": {
+        "summary": "Find the best matching GADM region for a location",
+        "description": "Given a geographic point (latitude and longitude), this tool returns the most likely GADM administrative region ID (GID). If `return_all` is true, it returns a list of all matching regions (from leaf to higher levels), sorted by bounding-box similarity. Typically used after /resolve_place.",
+        "operationId": "gadm_find_gid",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "lat": {
+                    "type": "number",
+                    "description": "Latitude of the location (in decimal degrees)"
+                  },
+                  "lon": {
+                    "type": "number",
+                    "description": "Longitude of the location (in decimal degrees)"
+                  },
+                  "bbox_area": {
+                    "type": "number",
+                    "nullable": true,
+                    "description": "Optional bounding box area (in square degrees) used to select the best matching GADM region when multiple regions contain the point"
+                  },
+                  "return_all": {
+                    "type": "boolean",
+                    "default": false,
+                    "description": "If true, returns a list of all matching GADM regions; otherwise returns only the best match"
+                  }
+                },
+                "required": [
+                  "lat",
+                  "lon"
+                ]
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Matching region(s) with status",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "oneOf": [
+                    {
+                      "type": "object",
+                      "properties": {
+                        "status": {
+                          "type": "string",
+                          "description": "Message describing result — e.g., success or failure"
+                        },
+                        "gid": {
+                          "type": [
+                            "string",
+                            "null"
+                          ],
+                          "description": "Best matching GADM ID (e.g., 'UGA.2.5_1'), or null if no match"
+                        }
+                      },
+                      "required": [
+                        "status",
+                        "gid"
+                      ]
+                    },
+                    {
+                      "type": "object",
+                      "properties": {
+                        "status": {
+                          "type": "string",
+                          "description": "Message describing result — e.g., success or failure"
+                        },
+                        "gids": {
+                          "type": "array",
+                          "items": {
+                            "type": "string"
+                          },
+                          "description": "List of all matching GADM region IDs"
+                        }
+                      },
+                      "required": [
+                        "status",
+                        "gids"
+                      ]
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/gadm/get_full_name": {
+      "post": {
+        "summary": "Get the full hierarchical name of a GADM region",
+        "description": "Returns a semicolon-separated string of the full hierarchy for a given GADM ID (e.g., 'Subcounty; County; Country'). This is useful for showing human-readable names after identifying a region by GID.",
+        "operationId": "gadm_get_full_name",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "gid": {
+                    "type": "string",
+                    "description": "The GADM ID to query, e.g., 'KEN.1.2_1'"
+                  }
+                },
+                "required": [
+                  "gid"
+                ]
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Full name result with status",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "status": {
+                      "type": "string",
+                      "description": "Indicates whether the GADM ID was found"
+                    },
+                    "full_name": {
+                      "type": [
+                        "string",
+                        "null"
+                      ],
+                      "description": "Hierarchical name from smallest to country level (semicolon-separated), or null if not found"
+                    }
+                  },
+                  "required": [
+                    "status",
+                    "full_name"
+                  ]
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/gadm/get_geometry_info": {
+      "post": {
+        "summary": "Get spatial metadata of a GADM region",
+        "description": "Returns the centroid and bounding box of the polygon associated with a given GADM ID. Results are flattened at the top level for easier access. Useful for map settings, distance reasoning, or visualisation.",
+        "operationId": "gadm_get_geometry_info",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "gid": {
+                    "type": "string",
+                    "description": "The GADM ID to query (e.g., 'UGA.2.5_1')"
+                  }
+                },
+                "required": [
+                  "gid"
+                ]
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Centroid and bounding box of the polygon region",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "status": {
+                      "type": "string",
+                      "description": "Message indicating success or failure"
+                    },
+                    "latitude": {
+                      "type": [
+                        "number",
+                        "null"
+                      ],
+                      "description": "Latitude of the centroid"
+                    },
+                    "longitude": {
+                      "type": [
+                        "number",
+                        "null"
+                      ],
+                      "description": "Longitude of the centroid"
+                    },
+                    "bbox_bounds": {
+                      "type": [
+                        "array",
+                        "null"
+                      ],
+                      "items": {
+                        "type": "number"
+                      },
+                      "minItems": 4,
+                      "maxItems": 4,
+                      "description": "[lat_min, lat_max, lon_min, lon_max]"
+                    },
+                    "polygon_area": {
+                      "type": [
+                        "number",
+                        "null"
+                      ],
+                      "description": "Area of the polygon in degrees²"
+                    },
+                    "bbox_area": {
+                      "type": [
+                        "number",
+                        "null"
+                      ],
+                      "description": "Area of the bounding box in degrees²"
+                    }
+                  },
+                  "required": [
+                    "status"
+                  ]
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/gadm/get_tree_info": {
+      "post": {
+        "summary": "Get hierarchical tree metadata for a GADM region",
+        "description": "Returns the level of the GADM ID and its relationship to other regions: parent (if any), children, and siblings. This is useful for navigating the administrative hierarchy or exploring neighbouring regions.",
+        "operationId": "gadm_get_tree_info",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "gid": {
+                    "type": "string",
+                    "description": "The GADM ID to query (e.g., 'ETH.2.9_1')"
+                  }
+                },
+                "required": [
+                  "gid"
+                ]
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Level, parent, children, and siblings",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "status": {
+                      "type": "string",
+                      "description": "Status message indicating success or failure"
+                    },
+                    "level": {
+                      "type": [
+                        "integer",
+                        "null"
+                      ],
+                      "description": "Administrative level (0 = country, 1 = province, ..., 5 = smallest)"
+                    },
+                    "parent": {
+                      "type": [
+                        "string",
+                        "null"
+                      ],
+                      "description": "Parent GADM ID, or null if this is level 0"
+                    },
+                    "children": {
+                      "type": [
+                        "array",
+                        "null"
+                      ],
+                      "items": {
+                        "type": "string"
+                      },
+                      "description": "List of child GIDs"
+                    },
+                    "siblings": {
+                      "type": [
+                        "array",
+                        "null"
+                      ],
+                      "items": {
+                        "type": "string"
+                      },
+                      "description": "List of sibling GIDs, including self"
+                    }
+                  },
+                  "required": [
+                    "status"
+                  ]
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/gadm/get_quick_summary": {
+      "post": {
+        "summary": "Return a human-readable summary of a GADM region",
+        "description": "Returns a concise, readable string describing the GADM region: full name, level, latitude, longitude, and GID. Useful for debugging or confirming spatial resolution results before data retrieval.",
+        "operationId": "gadm_get_quick_summary",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "gid": {
+                    "type": "string",
+                    "description": "GADM ID to summarise (e.g., 'ETH.1.3_1')"
+                  }
+                },
+                "required": [
+                  "gid"
+                ]
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Single-line summary of the region",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "summary": {
+                      "type": "string",
+                      "description": "Human-readable summary or error message"
+                    },
+                    "status": {
+                      "type": "string",
+                      "description": "Indicates success or failure of the summary request"
+                    }
+                  },
+                  "required": [
+                    "summary",
+                    "status"
+                  ]
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/soil/get_point": {
+      "post": {
+        "summary": "Retrieve soil data near a location",
+        "description": "Returns soil property values from the best matching sample among the top-k nearest points. The full list of valid property names is available in `column_names.json`. Any unknown property causes immediate failure.",
+        "operationId": "soil_get_point",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "place": {
+                    "description": "GADM ID string, place name string, or [lat, lon] coordinate pair.",
+                    "oneOf": [
+                      {
+                        "type": "string"
+                      },
+                      {
+                        "type": "array",
+                        "items": {
+                          "type": "number"
+                        },
+                        "minItems": 2,
+                        "maxItems": 2
+                      }
+                    ]
+                  },
+                  "properties": {
+                    "type": "array",
+                    "description": "List of requested soil properties. Valid names must match entries in `column_names.json`.",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "distance_top_k": {
+                    "type": "integer",
+                    "description": "Number of nearest samples to consider.",
+                    "minimum": 1,
+                    "default": 20
+                  },
+                  "distance_limit": {
+                    "type": "number",
+                    "description": "Maximum allowed distance in meters.",
+                    "minimum": 0,
+                    "default": 200000
+                  },
+                  "session_name": {
+                    "type": "string",
+                    "nullable": true,
+                    "description": "Optional session identifier for logging or traceability."
+                  }
+                },
+                "required": [
+                  "place",
+                  "properties"
+                ]
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Structured soil data response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "query_input": {
+                      "type": "object",
+                      "description": "Echo of user input"
+                    },
+                    "query_status": {
+                      "type": "string",
+                      "description": "Human-readable status message"
+                    },
+                    "query_output": {
+                      "type": "object",
+                      "nullable": true,
+                      "description": "Present only on success or partial success",
+                      "example": {
+                        "LAT_LONG": [
+                          52.13,
+                          5.37
+                        ],
+                        "GADM_IDS": [
+                          "NLD.5.2_1"
+                        ],
+                        "carbon": {
+                          "soil_organic_carbon": 12.4
+                        },
+                        "entry_key": "NL123456"
+                      }
+                    }
+                  },
+                  "required": [
+                    "query_input",
+                    "query_status",
+                    "query_output"
+                  ]
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/soil/get_map": {
+      "post": {
+        "summary": "Generate scatter-plot maps for soil properties across a region",
+        "description": "Extracts all samples within the target region and generates one PNG map per property. The response contains `query_input`, `query_status`, and a flat `query_output` mapping property names to either a plot URL or a warning message. For valid property names see `column_names.json`.",
+        "operationId": "soil_get_map",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "place": {
+                    "description": "GADM ID, place name string, or [lat, lon, bbox_area] triple",
+                    "oneOf": [
+                      {
+                        "type": "string"
+                      },
+                      {
+                        "type": "array",
+                        "items": {
+                          "type": "number"
+                        },
+                        "minItems": 3,
+                        "maxItems": 3
+                      }
+                    ]
+                  },
+                  "properties": {
+                    "type": "array",
+                    "description": "List of requested soil properties. Each entry must match a full_name in `column_names.json` (e.g., \"carbon:total (g/kg)\"). Maximum 5 properties per request.",
+                    "items": {
+                      "type": "string"
+                    },
+                    "maxItems": 5
+                  },
+                  "session_name": {
+                    "type": "string",
+                    "description": "Required session identifier. Used to namespace generated plot files (ASCII only)."
+                  },
+                  "kwargs": {
+                    "type": "object",
+                    "description": "Optional additional keyword arguments forwarded to the plotting function.",
+                    "additionalProperties": true
+                  }
+                },
+                "required": [
+                  "place",
+                  "properties",
+                  "session_name"
+                ]
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Map generation result containing URLs or warning strings per property",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "query_input": {
+                      "type": "object",
+                      "description": "Echo of the input parameters"
+                    },
+                    "query_status": {
+                      "type": "string",
+                      "description": "Success, failure, or partial success message"
+                    },
+                    "query_output": {
+                      "type": "object",
+                      "description": "Flat mapping: full property name → URL (.png) or warning string",
+                      "additionalProperties": {
+                        "type": "string"
+                      }
+                    }
+                  },
+                  "required": [
+                    "query_input",
+                    "query_status",
+                    "query_output"
+                  ]
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/health": {
+      "get": {
+        "summary": "Health check",
+        "description": "Returns status OK if the ERP-GPT-Europe backend is running.",
+        "operationId": "health_check",
+        "responses": {
+          "200": {
+            "description": "Health check successful",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "status": {
+                      "type": "string",
+                      "example": "OK"
+                    }
+                  },
+                  "required": [
+                    "status"
+                  ]
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

gpt_resources/starts.md

@@ -0,0 +1,9 @@
+What soil data can you access, and where does it come from?
+
+What is soil texture? Explain with an example in the UK.
+
+Show SOC distribution in France.
+
+Which European regions produce good wine, and how do soil and climate explain it?
+
+Show me photos from a LUCAS sample. Anywhere.

plot_utils.py

@@ -0,0 +1,223 @@
+import os
+import re
+from typing import List, Tuple, Literal
+
+import cartopy.crs as ccrs
+import cartopy.feature as cfeature
+import geopandas as gpd
+import matplotlib
+
+matplotlib.use("Agg")  # Use non-GUI backend for image generation
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.colors import ListedColormap
+
+from gadm_utils import GADMHandler
+
+
+def get_boundingbox(lats: np.ndarray, lons: np.ndarray) -> tuple[float, float, float, float]:
+    """
+    Compute the bounding box of a set of latitudes and longitudes,
+    returning in Nominatim convention: (lat_min, lat_max, lon_min, lon_max).
+    Handles wraparound at the 0/360 meridian for longitudes.
+    """
+    lat_min, lat_max = lats.min(), lats.max()
+
+    lons_360 = np.mod(lons, 360)
+    span_regular = lons.max() - lons.min()
+    span_wrapped = lons_360.max() - lons_360.min()
+    lons_used = lons_360 if span_wrapped < span_regular else lons
+    lon_min, lon_max = lons_used.min(), lons_used.max()
+
+    return lat_min, lat_max, lon_min, lon_max
+
+
+def scatter_plot(gadm_handler: GADMHandler,
+                 data: np.ndarray = None, is_categorical: bool = None,
+                 short_name: str = "plot", long_name: str = "", save_dir: str = "plots",
+                 session_name: str = None, cmap_float: str = "turbo", cmap_str: str = "tab20",
+                 scatter_size: float | Literal["auto"] = "auto",
+                 map_boundary_gadm_gids: List[str] = None,
+                 map_limits: Tuple[float, float, float, float] | Literal["data", "gadm_all", "gadm_first"] = "data",
+                 map_margin_ratio: float = 0.2,
+                 map_borders: bool = False, map_coastline: bool = False) -> str:
+    """
+    Generate a scatter plot with optional GADM boundaries and save to file.
+    """
+    # Validate and prepare data
+    if data is not None:
+        if data.ndim != 2 or data.shape[1] != 3:
+            raise ValueError("`data` must be an Nx3 array: [lat, lon, value].")
+        lats, lons, values = data[:, 0], data[:, 1], data[:, 2]
+    else:
+        lats = lons = values = np.array([])
+
+    has_data = data is not None and len(data) > 0
+
+    # Fail early if nothing to plot
+    if not has_data and not map_boundary_gadm_gids:
+        raise ValueError("Nothing to plot: both `data` and `map_boundary_gadm_gids` are empty.")
+
+    # Determine map limits
+    if map_limits == "data":
+        if not has_data:
+            raise ValueError("`map_limits='data'` requires `data` to be provided.")
+        lat0, lat1, lon0, lon1 = get_boundingbox(lats, lons)
+
+    elif "gadm" in map_limits:
+        if not map_boundary_gadm_gids:
+            raise ValueError("`map_boundary_gadm_gids` is required for GADM-based limits.")
+        all_lats, all_lons = [], []
+        index_for_limits = 1 if map_limits == "gadm_first" else len(map_boundary_gadm_gids)
+        for gid in map_boundary_gadm_gids[:index_for_limits]:
+            polygon = gadm_handler.get_polygon(gid)
+            if polygon is not None:
+                min_x, min_y, max_x, max_y = polygon.bounds
+                all_lons.extend([min_x, max_x])
+                all_lats.extend([min_y, max_y])
+        lat0, lat1, lon0, lon1 = get_boundingbox(np.array(all_lats), np.array(all_lons))
+
+    else:
+        lat0, lat1, lon0, lon1 = map_limits
+
+    # If data exists, expand map extent so scatter points are always visible
+    if has_data:
+        data_lat0 = float(np.min(lats))
+        data_lat1 = float(np.max(lats))
+        data_lon0 = float(np.min(lons))
+        data_lon1 = float(np.max(lons))
+
+        lat0 = min(lat0, data_lat0)
+        lat1 = max(lat1, data_lat1)
+        lon0 = min(lon0, data_lon0)
+        lon1 = max(lon1, data_lon1)
+
+    # Add margins
+    if isinstance(map_limits, str):
+        dlat = (lat1 - lat0) * map_margin_ratio or 1.0
+        dlon = (lon1 - lon0) * map_margin_ratio or 1.0
+        lat0, lat1 = lat0 - dlat, lat1 + dlat
+        lon0, lon1 = lon0 - dlon, lon1 + dlon
+
+    # Setup figure
+    base = 6
+    width = lon1 - lon0
+    height = lat1 - lat0
+    plt.figure(figsize=(base * (width / height), base), dpi=200)
+    ax = plt.axes(projection=ccrs.PlateCarree())
+    ax.set_extent([lon0, lon1, lat0, lat1], crs=ccrs.PlateCarree())
+    ax.set_aspect("equal", adjustable="box")
+
+    tick_font = 8 if has_data else 10
+    title_font = 10 if has_data else 12
+
+    # Gridlines
+    gl = ax.gridlines(draw_labels=True, linewidth=0.3, color='gray', alpha=0.7, linestyle='--')
+    gl.top_labels = False
+    gl.right_labels = False
+    gl.xlabel_style = {'size': tick_font}
+    gl.ylabel_style = {'size': tick_font}
+
+    # Base map
+    if map_coastline:
+        ax.add_feature(cfeature.COASTLINE, linewidth=1.0, color="k")
+    if map_borders:
+        ax.add_feature(cfeature.BORDERS, linewidth=0.8, color="k")
+    ax.add_feature(cfeature.LAND, facecolor="ivory")
+    ax.add_feature(cfeature.OCEAN, facecolor="lightblue")
+
+    # GADM boundaries
+    if map_boundary_gadm_gids:
+        for gid in map_boundary_gadm_gids:
+            polygon = gadm_handler.get_polygon(gid)
+            if polygon is not None:
+                gpd.GeoSeries([polygon]).plot(ax=ax, facecolor='none', edgecolor='gray', linewidth=0.3)
+        if map_limits == "gadm_first":
+            gid = map_boundary_gadm_gids[0]
+            polygon = gadm_handler.get_polygon(gid)
+            if polygon is not None:
+                gpd.GeoSeries([polygon]).plot(ax=ax, facecolor='none', edgecolor='black', linewidth=0.6)
+            info = gadm_handler.get_full_info(gid)
+            if info:
+                lat_c = info["geometry"]["latitude"]
+                lon_c = info["geometry"]["longitude"]
+                name = info["full_name"].split(";")[0]
+                plt.text(lon_c, lat_c, name, fontsize=tick_font, ha="center", va="center")
+
+    # Scatter plot
+    if has_data:
+        if scatter_size == "auto":
+            count = len(lats)
+            base_size = 40
+            scatter_size = base_size / (np.log10(count + 1) + 1)
+            scatter_size = np.clip(scatter_size, 5, 30)
+
+        if is_categorical is None:
+            is_categorical = np.issubdtype(values.dtype, np.str_)
+
+        rasterize = len(lats) > 10000
+        if is_categorical:
+            categories, values_encoded = np.unique(values.astype(str), return_inverse=True)
+            num_categories = len(categories)
+            cmap_base = plt.get_cmap(cmap_str)
+            if hasattr(cmap_base, 'colors'):
+                cmap_colors = cmap_base.colors[:num_categories]
+                cmap_used = ListedColormap(cmap_colors)
+            else:
+                cmap_used = cmap_base
+
+            sc = ax.scatter(lons, lats, c=values_encoded, cmap=cmap_used, s=scatter_size,
+                            linewidth=0.0, transform=ccrs.PlateCarree(), zorder=2,
+                            rasterized=rasterize, edgecolors='none')
+            single_color_width = (num_categories - 1) / num_categories
+            cbar = plt.colorbar(sc, ax=ax, orientation='vertical', shrink=0.6,
+                                ticks=np.linspace(single_color_width / 2,
+                                                  num_categories - 1 - single_color_width / 2,
+                                                  num_categories))
+            cbar.ax.set_yticklabels(categories)
+            cbar.set_label(long_name, fontsize=tick_font)
+            cbar.ax.tick_params(labelsize=tick_font)
+        else:
+            try:
+                vmin = float(np.percentile(values, 1))
+                vmax = float(np.percentile(values, 99))
+            except Exception:  # noqa
+                vmin = vmax = None
+
+            norm = plt.Normalize(vmin=vmin, vmax=vmax) if vmin is not None and vmax is not None else None
+
+            sc = ax.scatter(lons, lats, c=values, cmap=cmap_float, s=scatter_size,
+                            linewidth=0.0, transform=ccrs.PlateCarree(), zorder=2, norm=norm,
+                            rasterized=rasterize, edgecolors='none')
+
+            cbar = plt.colorbar(sc, ax=ax, orientation='vertical', shrink=0.6)
+            cbar.set_label(long_name, fontsize=tick_font)
+            cbar.ax.tick_params(labelsize=tick_font)
+
+    ax.set_title(long_name, fontsize=title_font)
+
+    # Save figure with safe filename
+    if session_name is None or session_name == "":
+        session_name = "default_session"
+    safe_session = re.sub(r'[^a-zA-Z0-9_-]', '_', session_name)
+    save_dir = os.path.join(save_dir, safe_session)
+    os.makedirs(save_dir, exist_ok=True)
+
+    # build base filename
+    base_name = re.sub(r'[^a-zA-Z0-9_-]', '_', short_name)
+    ext = ".png"
+    filepath = os.path.join(save_dir, f"{base_name}{ext}")
+
+    # if exists, append -1, -2, ...
+    if os.path.exists(filepath):
+        i = 1
+        while True:
+            filepath = os.path.join(save_dir, f"{base_name}-{i}{ext}")
+            if not os.path.exists(filepath):
+                break
+            i += 1
+
+    plt.savefig(filepath, bbox_inches="tight")
+    plt.close()
+
+    return filepath

requirements.txt

@@ -0,0 +1,11 @@
+Cartopy
+geopandas
+geopy
+matplotlib
+shapely
+
+flask
+numpy
+pandas
+
+pycountry