geospatial-mcp-server 0.1.0__tar.gz

geospatial_mcp_server-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.env
+.venv/
+venv/
+*.log
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/

geospatial_mcp_server-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AiAgentKarl
+
+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.

geospatial_mcp_server-0.1.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: geospatial-mcp-server
+Version: 0.1.0
+Summary: Geospatial MCP Server — Geocoding, POI-Suche, Routing und Gebietsstatistiken via OpenStreetMap fuer AI Agents
+Project-URL: Homepage, https://github.com/AiAgentKarl/geospatial-mcp-server
+Project-URL: Repository, https://github.com/AiAgentKarl/geospatial-mcp-server
+Project-URL: Issues, https://github.com/AiAgentKarl/geospatial-mcp-server/issues
+Author: AiAgentKarl
+License: MIT
+License-File: LICENSE
+Keywords: ai-agents,geocoding,geospatial,mcp,nominatim,openstreetmap,osm,overpass
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Description-Content-Type: text/markdown
+
+# geospatial-mcp-server
+
+<!-- mcp-name: geospatial-mcp-server -->
+
+MCP Server for geospatial data — gives AI agents access to geocoding, reverse geocoding, POI search, routing info, and area statistics via OpenStreetMap.
+
+**100% free, no API key required.** Uses OpenStreetMap Nominatim + Overpass API.
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `geocode` | Convert address/place name to coordinates |
+| `reverse_geocode` | Convert coordinates to address |
+| `search_nearby` | Find POIs nearby (restaurants, hospitals, schools, etc.) |
+| `get_route_info` | Distance and bearing between two points |
+| `get_area_stats` | Population, area, type info for a place |
+| `find_boundaries` | Administrative boundaries of a place |
+| `search_pois` | Search points of interest by keyword in an area |
+
+## Installation
+
+```bash
+pip install geospatial-mcp-server
+```
+
+## Usage with Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "geospatial": {
+      "command": "geospatial-server"
+    }
+  }
+}
+```
+
+Or with uvx (no install needed):
+
+```json
+{
+  "mcpServers": {
+    "geospatial": {
+      "command": "uvx",
+      "args": ["geospatial-mcp-server"]
+    }
+  }
+}
+```
+
+## Examples
+
+- "Where is the Eiffel Tower?" → `geocode("Eiffel Tower, Paris")`
+- "What's at 48.8566, 2.3522?" → `reverse_geocode(48.8566, 2.3522)`
+- "Find restaurants near me" → `search_nearby(48.8566, 2.3522, "restaurant")`
+- "How far is Berlin from Munich?" → `get_route_info("Berlin", "Munich")`
+- "Tell me about Tokyo" → `get_area_stats("Tokyo")`
+
+## Data Sources
+
+- [OpenStreetMap Nominatim](https://nominatim.openstreetmap.org/) — Geocoding & reverse geocoding
+- [Overpass API](https://overpass-api.de/) — POI search & spatial queries
+
+## License
+
+MIT

geospatial_mcp_server-0.1.0/README.md

@@ -0,0 +1,69 @@
+# geospatial-mcp-server
+
+<!-- mcp-name: geospatial-mcp-server -->
+
+MCP Server for geospatial data — gives AI agents access to geocoding, reverse geocoding, POI search, routing info, and area statistics via OpenStreetMap.
+
+**100% free, no API key required.** Uses OpenStreetMap Nominatim + Overpass API.
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `geocode` | Convert address/place name to coordinates |
+| `reverse_geocode` | Convert coordinates to address |
+| `search_nearby` | Find POIs nearby (restaurants, hospitals, schools, etc.) |
+| `get_route_info` | Distance and bearing between two points |
+| `get_area_stats` | Population, area, type info for a place |
+| `find_boundaries` | Administrative boundaries of a place |
+| `search_pois` | Search points of interest by keyword in an area |
+
+## Installation
+
+```bash
+pip install geospatial-mcp-server
+```
+
+## Usage with Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "geospatial": {
+      "command": "geospatial-server"
+    }
+  }
+}
+```
+
+Or with uvx (no install needed):
+
+```json
+{
+  "mcpServers": {
+    "geospatial": {
+      "command": "uvx",
+      "args": ["geospatial-mcp-server"]
+    }
+  }
+}
+```
+
+## Examples
+
+- "Where is the Eiffel Tower?" → `geocode("Eiffel Tower, Paris")`
+- "What's at 48.8566, 2.3522?" → `reverse_geocode(48.8566, 2.3522)`
+- "Find restaurants near me" → `search_nearby(48.8566, 2.3522, "restaurant")`
+- "How far is Berlin from Munich?" → `get_route_info("Berlin", "Munich")`
+- "Tell me about Tokyo" → `get_area_stats("Tokyo")`
+
+## Data Sources
+
+- [OpenStreetMap Nominatim](https://nominatim.openstreetmap.org/) — Geocoding & reverse geocoding
+- [Overpass API](https://overpass-api.de/) — POI search & spatial queries
+
+## License
+
+MIT

geospatial_mcp_server-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "geospatial-mcp-server"
+version = "0.1.0"
+description = "Geospatial MCP Server — Geocoding, POI-Suche, Routing und Gebietsstatistiken via OpenStreetMap fuer AI Agents"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [
+    {name = "AiAgentKarl"}
+]
+keywords = ["mcp", "geospatial", "openstreetmap", "geocoding", "osm", "nominatim", "overpass", "ai-agents"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: GIS",
+]
+dependencies = [
+    "mcp>=1.0.0",
+    "httpx>=0.27.0",
+    "pydantic>=2.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/AiAgentKarl/geospatial-mcp-server"
+Repository = "https://github.com/AiAgentKarl/geospatial-mcp-server"
+Issues = "https://github.com/AiAgentKarl/geospatial-mcp-server/issues"
+
+[project.scripts]
+geospatial-server = "src.server:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]

geospatial_mcp_server-0.1.0/src/__init__.py

@@ -0,0 +1 @@
+# Geospatial MCP Server — Geodaten fuer AI Agents

geospatial_mcp_server-0.1.0/src/clients/__init__.py

@@ -0,0 +1 @@
+# OSM API Clients

geospatial_mcp_server-0.1.0/src/clients/osm.py

@@ -0,0 +1,182 @@
+"""
+OpenStreetMap API Client — Nominatim + Overpass
+Nutzt httpx fuer async HTTP-Anfragen.
+"""
+
+import httpx
+from typing import Any
+
+
+# Nominatim verlangt einen User-Agent Header
+USER_AGENT = "GeospatialMCPServer/0.1.0"
+NOMINATIM_BASE = "https://nominatim.openstreetmap.org"
+OVERPASS_URL = "https://overpass-api.de/api/interpreter"
+
+# Timeout fuer alle Anfragen (Overpass kann langsam sein)
+TIMEOUT = httpx.Timeout(30.0, connect=10.0)
+
+
+def _get_headers() -> dict[str, str]:
+    """Standard-Headers fuer Nominatim (User-Agent ist Pflicht)."""
+    return {
+        "User-Agent": USER_AGENT,
+        "Accept": "application/json",
+    }
+
+
+async def nominatim_search(query: str, limit: int = 5) -> list[dict[str, Any]]:
+    """
+    Geocoding: Adresse/Ortsname -> Koordinaten.
+    Nutzt Nominatim /search Endpoint.
+    """
+    params = {
+        "q": query,
+        "format": "json",
+        "limit": limit,
+        "addressdetails": 1,
+        "extratags": 1,
+    }
+    async with httpx.AsyncClient(timeout=TIMEOUT) as client:
+        response = await client.get(
+            f"{NOMINATIM_BASE}/search",
+            params=params,
+            headers=_get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+
+async def nominatim_reverse(lat: float, lon: float) -> dict[str, Any]:
+    """
+    Reverse Geocoding: Koordinaten -> Adresse.
+    Nutzt Nominatim /reverse Endpoint.
+    """
+    params = {
+        "lat": lat,
+        "lon": lon,
+        "format": "json",
+        "addressdetails": 1,
+        "extratags": 1,
+    }
+    async with httpx.AsyncClient(timeout=TIMEOUT) as client:
+        response = await client.get(
+            f"{NOMINATIM_BASE}/reverse",
+            params=params,
+            headers=_get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+
+async def nominatim_lookup(query: str) -> dict[str, Any] | None:
+    """
+    Einzelnen Ort suchen und Details zurueckgeben.
+    Gibt das erste Ergebnis zurueck oder None.
+    """
+    results = await nominatim_search(query, limit=1)
+    if results:
+        return results[0]
+    return None
+
+
+async def overpass_query(query: str) -> dict[str, Any]:
+    """
+    Overpass API Abfrage ausfuehren.
+    Erwartet eine vollstaendige Overpass QL Query.
+    """
+    async with httpx.AsyncClient(timeout=TIMEOUT) as client:
+        response = await client.post(
+            OVERPASS_URL,
+            data={"data": query},
+            headers={"User-Agent": USER_AGENT},
+        )
+        response.raise_for_status()
+        return response.json()
+
+
+async def overpass_nearby(
+    lat: float,
+    lon: float,
+    category: str,
+    radius_m: int = 1000,
+) -> list[dict[str, Any]]:
+    """
+    POIs in der Naehe suchen via Overpass.
+    Unterstuetzte Kategorien werden auf OSM-Tags gemappt.
+    """
+    # Kategorie auf OSM-Tags mappen
+    tag_mapping = {
+        "restaurant": '"amenity"="restaurant"',
+        "cafe": '"amenity"="cafe"',
+        "bar": '"amenity"="bar"',
+        "fast_food": '"amenity"="fast_food"',
+        "hospital": '"amenity"="hospital"',
+        "pharmacy": '"amenity"="pharmacy"',
+        "doctor": '"amenity"="doctors"',
+        "school": '"amenity"="school"',
+        "university": '"amenity"="university"',
+        "kindergarten": '"amenity"="kindergarten"',
+        "bank": '"amenity"="bank"',
+        "atm": '"amenity"="atm"',
+        "fuel": '"amenity"="fuel"',
+        "parking": '"amenity"="parking"',
+        "supermarket": '"shop"="supermarket"',
+        "bakery": '"shop"="bakery"',
+        "hotel": '"tourism"="hotel"',
+        "museum": '"tourism"="museum"',
+        "park": '"leisure"="park"',
+        "playground": '"leisure"="playground"',
+        "police": '"amenity"="police"',
+        "fire_station": '"amenity"="fire_station"',
+        "post_office": '"amenity"="post_office"',
+        "library": '"amenity"="library"',
+        "cinema": '"amenity"="cinema"',
+        "theatre": '"amenity"="theatre"',
+        "gym": '"leisure"="fitness_centre"',
+        "swimming_pool": '"leisure"="swimming_pool"',
+        "bus_stop": '"highway"="bus_stop"',
+        "train_station": '"railway"="station"',
+        "subway": '"railway"="subway_entrance"',
+        "charging_station": '"amenity"="charging_station"',
+    }
+
+    # Wenn Kategorie bekannt, nutze spezifischen Tag
+    osm_filter = tag_mapping.get(category.lower())
+    if not osm_filter:
+        # Fallback: Suche nach Name oder beliebigem Amenity-Tag
+        osm_filter = f'"amenity"="{category}"'
+
+    query = f"""
+    [out:json][timeout:25];
+    (
+      node[{osm_filter}](around:{radius_m},{lat},{lon});
+      way[{osm_filter}](around:{radius_m},{lat},{lon});
+    );
+    out center body;
+    """
+
+    result = await overpass_query(query)
+    return result.get("elements", [])
+
+
+async def overpass_search_pois(
+    keyword: str,
+    lat: float,
+    lon: float,
+    radius_m: int = 5000,
+) -> list[dict[str, Any]]:
+    """
+    POIs nach Freitext-Keyword suchen via Overpass.
+    Sucht in name-Tags innerhalb des Radius.
+    """
+    query = f"""
+    [out:json][timeout:25];
+    (
+      node["name"~"{keyword}",i](around:{radius_m},{lat},{lon});
+      way["name"~"{keyword}",i](around:{radius_m},{lat},{lon});
+    );
+    out center body;
+    """
+
+    result = await overpass_query(query)
+    return result.get("elements", [])

geospatial_mcp_server-0.1.0/src/server.py

@@ -0,0 +1,149 @@
+"""
+Geospatial MCP Server — Geodaten fuer AI Agents.
+Geocoding, POI-Suche, Routing und Gebietsstatistiken via OpenStreetMap.
+"""
+
+from mcp.server.fastmcp import FastMCP
+
+from src.tools.geo import (
+    geocode,
+    reverse_geocode,
+    search_nearby,
+    get_route_info,
+    get_area_stats,
+    find_boundaries,
+    search_pois,
+)
+
+# FastMCP Server erstellen
+mcp = FastMCP(
+    "geospatial-mcp-server",
+    instructions=(
+        "Geospatial data server for AI agents. "
+        "Provides geocoding, reverse geocoding, nearby POI search, "
+        "distance calculation, area statistics, boundary lookup, "
+        "and keyword-based POI search. "
+        "All data comes from OpenStreetMap (Nominatim + Overpass API). "
+        "No API key required."
+    ),
+)
+
+
+# --- Tools registrieren ---
+
+@mcp.tool()
+async def geocode_tool(query: str) -> dict:
+    """Convert an address or place name to geographic coordinates.
+
+    Args:
+        query: Address or place name (e.g. "Eiffel Tower, Paris", "1600 Pennsylvania Ave, Washington DC")
+
+    Returns:
+        Coordinates, address details and result type
+    """
+    return await geocode(query)
+
+
+@mcp.tool()
+async def reverse_geocode_tool(lat: float, lon: float) -> dict:
+    """Convert geographic coordinates to an address.
+
+    Args:
+        lat: Latitude (e.g. 48.8566)
+        lon: Longitude (e.g. 2.3522)
+
+    Returns:
+        Address and location details
+    """
+    return await reverse_geocode(lat, lon)
+
+
+@mcp.tool()
+async def search_nearby_tool(
+    lat: float,
+    lon: float,
+    category: str,
+    radius_m: int = 1000,
+) -> dict:
+    """Find points of interest nearby (restaurants, hospitals, schools, etc.).
+
+    Args:
+        lat: Center latitude
+        lon: Center longitude
+        category: POI category — one of: restaurant, cafe, bar, fast_food, hospital, pharmacy, doctor, school, university, kindergarten, bank, atm, fuel, parking, supermarket, bakery, hotel, museum, park, playground, police, fire_station, post_office, library, cinema, theatre, gym, swimming_pool, bus_stop, train_station, subway, charging_station
+        radius_m: Search radius in meters (default: 1000, max: 10000)
+
+    Returns:
+        List of nearby POIs with name, coordinates, distance
+    """
+    return await search_nearby(lat, lon, category, radius_m)
+
+
+@mcp.tool()
+async def get_route_info_tool(origin: str, destination: str) -> dict:
+    """Calculate distance and direction between two places (straight line).
+
+    Args:
+        origin: Starting place (e.g. "Berlin")
+        destination: Target place (e.g. "Munich")
+
+    Returns:
+        Distance in km/miles, bearing, direction, coordinates of both points
+    """
+    return await get_route_info(origin, destination)
+
+
+@mcp.tool()
+async def get_area_stats_tool(place_name: str) -> dict:
+    """Get statistics about a place (population, area, type).
+
+    Args:
+        place_name: Name of the place (e.g. "Berlin", "Tokyo", "New York")
+
+    Returns:
+        Population, area, administrative type, Wikipedia link and more
+    """
+    return await get_area_stats(place_name)
+
+
+@mcp.tool()
+async def find_boundaries_tool(place_name: str) -> dict:
+    """Find administrative boundaries of a place.
+
+    Args:
+        place_name: Name of the place (e.g. "Bavaria", "California", "Paris")
+
+    Returns:
+        Boundary info with bounding box and administrative hierarchy
+    """
+    return await find_boundaries(place_name)
+
+
+@mcp.tool()
+async def search_pois_tool(
+    query: str,
+    lat: float,
+    lon: float,
+    radius_m: int = 5000,
+) -> dict:
+    """Search points of interest by keyword in an area.
+
+    Args:
+        query: Search keyword (e.g. "Starbucks", "Museum", "Train Station")
+        lat: Center latitude
+        lon: Center longitude
+        radius_m: Search radius in meters (default: 5000, max: 25000)
+
+    Returns:
+        List of matching POIs with name, coordinates, distance
+    """
+    return await search_pois(query, lat, lon, radius_m)
+
+
+def main():
+    """Server starten."""
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

geospatial_mcp_server-0.1.0/src/tools/__init__.py

@@ -0,0 +1 @@
+# Geospatial Tool-Definitionen

geospatial_mcp_server-0.1.0/src/tools/geo.py

@@ -0,0 +1,430 @@
+"""
+Geospatial MCP Tools — 7 Tools fuer Geodaten.
+Nutzt OpenStreetMap Nominatim + Overpass API.
+"""
+
+import math
+from typing import Any
+
+from src.clients.osm import (
+    nominatim_search,
+    nominatim_reverse,
+    nominatim_lookup,
+    overpass_nearby,
+    overpass_search_pois,
+)
+
+
+def _haversine(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    """
+    Haversine-Formel: Berechnet Entfernung zwischen zwei Koordinaten in km.
+    """
+    R = 6371.0  # Erdradius in km
+
+    lat1_r = math.radians(lat1)
+    lat2_r = math.radians(lat2)
+    dlat = math.radians(lat2 - lat1)
+    dlon = math.radians(lon2 - lon1)
+
+    a = math.sin(dlat / 2) ** 2 + math.cos(lat1_r) * math.cos(lat2_r) * math.sin(dlon / 2) ** 2
+    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+
+    return R * c
+
+
+def _bearing(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    """Berechnet die Peilung (Bearing) in Grad von Punkt 1 zu Punkt 2."""
+    lat1_r = math.radians(lat1)
+    lat2_r = math.radians(lat2)
+    dlon = math.radians(lon2 - lon1)
+
+    x = math.sin(dlon) * math.cos(lat2_r)
+    y = math.cos(lat1_r) * math.sin(lat2_r) - math.sin(lat1_r) * math.cos(lat2_r) * math.cos(dlon)
+
+    bearing_rad = math.atan2(x, y)
+    return (math.degrees(bearing_rad) + 360) % 360
+
+
+def _bearing_to_direction(bearing: float) -> str:
+    """Wandelt Bearing in Himmelsrichtung um."""
+    directions = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"]
+    index = round(bearing / 45) % 8
+    return directions[index]
+
+
+def _format_element(element: dict[str, Any]) -> dict[str, Any]:
+    """Formatiert ein Overpass-Element fuer die Ausgabe."""
+    tags = element.get("tags", {})
+    # Koordinaten: Bei Way-Elementen center nutzen
+    lat = element.get("lat") or element.get("center", {}).get("lat")
+    lon = element.get("lon") or element.get("center", {}).get("lon")
+
+    result = {
+        "name": tags.get("name", "Unbekannt"),
+        "type": element.get("type", "unknown"),
+        "lat": lat,
+        "lon": lon,
+    }
+
+    # Nuetzliche Tags hinzufuegen wenn vorhanden
+    useful_tags = [
+        "addr:street", "addr:housenumber", "addr:city", "addr:postcode",
+        "phone", "website", "opening_hours", "cuisine", "brand",
+        "wheelchair", "internet_access",
+    ]
+    for tag in useful_tags:
+        if tag in tags:
+            result[tag.replace(":", "_")] = tags[tag]
+
+    return result
+
+
+async def geocode(query: str) -> dict[str, Any]:
+    """
+    Adresse oder Ortsname in Koordinaten umwandeln.
+
+    Args:
+        query: Adresse oder Ortsname (z.B. "Brandenburger Tor, Berlin")
+
+    Returns:
+        Koordinaten, Adressdetails und Typ des Ergebnisses
+    """
+    results = await nominatim_search(query, limit=5)
+
+    if not results:
+        return {"error": f"Keine Ergebnisse fuer '{query}' gefunden."}
+
+    formatted = []
+    for r in results:
+        entry = {
+            "name": r.get("display_name", ""),
+            "lat": float(r.get("lat", 0)),
+            "lon": float(r.get("lon", 0)),
+            "type": r.get("type", "unknown"),
+            "class": r.get("class", "unknown"),
+            "importance": round(float(r.get("importance", 0)), 4),
+        }
+        # Adressdetails hinzufuegen
+        address = r.get("address", {})
+        if address:
+            entry["address"] = {
+                k: v for k, v in address.items()
+                if k not in ("country_code",)
+            }
+        formatted.append(entry)
+
+    return {
+        "query": query,
+        "results_count": len(formatted),
+        "results": formatted,
+    }
+
+
+async def reverse_geocode(lat: float, lon: float) -> dict[str, Any]:
+    """
+    Koordinaten in Adresse umwandeln.
+
+    Args:
+        lat: Breitengrad (z.B. 48.8566)
+        lon: Laengengrad (z.B. 2.3522)
+
+    Returns:
+        Adresse und Details zum Standort
+    """
+    try:
+        result = await nominatim_reverse(lat, lon)
+    except Exception as e:
+        return {"error": f"Reverse Geocoding fehlgeschlagen: {str(e)}"}
+
+    if "error" in result:
+        return {"error": result["error"]}
+
+    address = result.get("address", {})
+    return {
+        "lat": lat,
+        "lon": lon,
+        "display_name": result.get("display_name", ""),
+        "type": result.get("type", "unknown"),
+        "class": result.get("class", "unknown"),
+        "address": {
+            k: v for k, v in address.items()
+            if k not in ("country_code",)
+        },
+    }
+
+
+async def search_nearby(
+    lat: float,
+    lon: float,
+    category: str,
+    radius_m: int = 1000,
+) -> dict[str, Any]:
+    """
+    POIs in der Naehe suchen (Restaurants, Krankenhaeuser, Schulen, etc.).
+
+    Args:
+        lat: Breitengrad des Mittelpunkts
+        lon: Laengengrad des Mittelpunkts
+        category: Kategorie (restaurant, hospital, school, pharmacy, supermarket, hotel, park, bank, fuel, etc.)
+        radius_m: Suchradius in Metern (Standard: 1000, Max: 10000)
+
+    Returns:
+        Liste der gefundenen POIs mit Name, Koordinaten und Details
+    """
+    # Radius begrenzen
+    radius_m = min(max(radius_m, 100), 10000)
+
+    try:
+        elements = await overpass_nearby(lat, lon, category, radius_m)
+    except Exception as e:
+        return {"error": f"Overpass-Abfrage fehlgeschlagen: {str(e)}"}
+
+    # Ergebnisse formatieren und Entfernung berechnen
+    pois = []
+    for el in elements:
+        formatted = _format_element(el)
+        if formatted["lat"] and formatted["lon"]:
+            formatted["distance_m"] = round(
+                _haversine(lat, lon, formatted["lat"], formatted["lon"]) * 1000
+            )
+        pois.append(formatted)
+
+    # Nach Entfernung sortieren
+    pois.sort(key=lambda x: x.get("distance_m", 99999))
+
+    return {
+        "center": {"lat": lat, "lon": lon},
+        "category": category,
+        "radius_m": radius_m,
+        "results_count": len(pois),
+        "results": pois[:50],  # Max 50 Ergebnisse
+    }
+
+
+async def get_route_info(origin: str, destination: str) -> dict[str, Any]:
+    """
+    Entfernung und Richtung zwischen zwei Orten berechnen.
+
+    Args:
+        origin: Startort (z.B. "Berlin")
+        destination: Zielort (z.B. "Muenchen")
+
+    Returns:
+        Luftlinie-Entfernung in km, Richtung und Koordinaten beider Punkte
+    """
+    # Beide Orte geocoden
+    origin_result = await nominatim_lookup(origin)
+    if not origin_result:
+        return {"error": f"Startort '{origin}' nicht gefunden."}
+
+    dest_result = await nominatim_lookup(destination)
+    if not dest_result:
+        return {"error": f"Zielort '{destination}' nicht gefunden."}
+
+    lat1 = float(origin_result["lat"])
+    lon1 = float(origin_result["lon"])
+    lat2 = float(dest_result["lat"])
+    lon2 = float(dest_result["lon"])
+
+    distance_km = _haversine(lat1, lon1, lat2, lon2)
+    bearing_deg = _bearing(lat1, lon1, lat2, lon2)
+    direction = _bearing_to_direction(bearing_deg)
+
+    return {
+        "origin": {
+            "name": origin_result.get("display_name", origin),
+            "lat": lat1,
+            "lon": lon1,
+        },
+        "destination": {
+            "name": dest_result.get("display_name", destination),
+            "lat": lat2,
+            "lon": lon2,
+        },
+        "distance_km": round(distance_km, 2),
+        "distance_miles": round(distance_km * 0.621371, 2),
+        "bearing_degrees": round(bearing_deg, 1),
+        "direction": direction,
+        "note": "Luftlinie (Haversine). Tatsaechliche Strecke kann laenger sein.",
+    }
+
+
+async def get_area_stats(place_name: str) -> dict[str, Any]:
+    """
+    Statistiken ueber einen Ort abrufen (Bevoelkerung, Flaeche, Typ).
+
+    Args:
+        place_name: Name des Ortes (z.B. "Berlin", "Tokyo", "New York")
+
+    Returns:
+        Bevoelkerung, Flaeche, Verwaltungstyp und weitere Infos
+    """
+    result = await nominatim_lookup(place_name)
+    if not result:
+        return {"error": f"Ort '{place_name}' nicht gefunden."}
+
+    address = result.get("address", {})
+    extratags = result.get("extratags", {})
+
+    stats: dict[str, Any] = {
+        "name": result.get("display_name", place_name),
+        "lat": float(result.get("lat", 0)),
+        "lon": float(result.get("lon", 0)),
+        "type": result.get("type", "unknown"),
+        "class": result.get("class", "unknown"),
+        "importance": round(float(result.get("importance", 0)), 4),
+    }
+
+    # Bounding Box wenn vorhanden
+    bbox = result.get("boundingbox")
+    if bbox and len(bbox) == 4:
+        stats["bounding_box"] = {
+            "south": float(bbox[0]),
+            "north": float(bbox[1]),
+            "west": float(bbox[2]),
+            "east": float(bbox[3]),
+        }
+        # Ungefaehre Flaeche aus Bounding Box berechnen
+        height_km = _haversine(float(bbox[0]), float(bbox[2]), float(bbox[1]), float(bbox[2]))
+        width_km = _haversine(float(bbox[0]), float(bbox[2]), float(bbox[0]), float(bbox[3]))
+        stats["approx_area_km2"] = round(height_km * width_km, 2)
+
+    # Extratags auswerten (Population, Wikipedia, etc.)
+    if extratags:
+        if "population" in extratags:
+            try:
+                stats["population"] = int(extratags["population"])
+            except (ValueError, TypeError):
+                stats["population"] = extratags["population"]
+        if "wikipedia" in extratags:
+            stats["wikipedia"] = extratags["wikipedia"]
+        if "wikidata" in extratags:
+            stats["wikidata"] = extratags["wikidata"]
+        if "website" in extratags:
+            stats["website"] = extratags["website"]
+        if "capital" in extratags:
+            stats["capital"] = extratags["capital"]
+        if "timezone" in extratags:
+            stats["timezone"] = extratags["timezone"]
+
+    # Adress-Hierarchie
+    if address:
+        stats["address"] = {
+            k: v for k, v in address.items()
+            if k not in ("country_code",)
+        }
+
+    return stats
+
+
+async def find_boundaries(place_name: str) -> dict[str, Any]:
+    """
+    Administrative Grenzen eines Ortes finden.
+
+    Args:
+        place_name: Name des Ortes (z.B. "Bayern", "California", "Paris")
+
+    Returns:
+        Verwaltungsgrenzen mit Bounding Box und Hierarchie
+    """
+    # Nominatim-Suche mit Polygon-Bounding-Box
+    results = await nominatim_search(place_name, limit=3)
+
+    if not results:
+        return {"error": f"Keine Grenzen fuer '{place_name}' gefunden."}
+
+    # Beste Ergebnisse filtern (bevorzugt administrative Grenzen)
+    boundaries = []
+    for r in results:
+        entry: dict[str, Any] = {
+            "name": r.get("display_name", ""),
+            "type": r.get("type", "unknown"),
+            "class": r.get("class", "unknown"),
+            "osm_type": r.get("osm_type", ""),
+            "osm_id": r.get("osm_id", ""),
+            "lat": float(r.get("lat", 0)),
+            "lon": float(r.get("lon", 0)),
+        }
+
+        # Bounding Box
+        bbox = r.get("boundingbox")
+        if bbox and len(bbox) == 4:
+            entry["bounding_box"] = {
+                "south": float(bbox[0]),
+                "north": float(bbox[1]),
+                "west": float(bbox[2]),
+                "east": float(bbox[3]),
+            }
+
+        # Adress-Hierarchie zeigt administrative Ebenen
+        address = r.get("address", {})
+        if address:
+            entry["admin_hierarchy"] = {
+                k: v for k, v in address.items()
+                if k not in ("country_code",)
+            }
+
+        # Extratags fuer weitere Details
+        extratags = r.get("extratags", {})
+        if extratags:
+            admin_level = extratags.get("admin_level") or extratags.get("linked_place")
+            if admin_level:
+                entry["admin_level"] = admin_level
+            if "border_type" in extratags:
+                entry["border_type"] = extratags["border_type"]
+
+        boundaries.append(entry)
+
+    return {
+        "query": place_name,
+        "results_count": len(boundaries),
+        "boundaries": boundaries,
+    }
+
+
+async def search_pois(
+    query: str,
+    lat: float,
+    lon: float,
+    radius_m: int = 5000,
+) -> dict[str, Any]:
+    """
+    Points of Interest nach Freitext-Keyword in einem Gebiet suchen.
+
+    Args:
+        query: Suchbegriff (z.B. "Starbucks", "Museum", "Bahnhof")
+        lat: Breitengrad des Mittelpunkts
+        lon: Laengengrad des Mittelpunkts
+        radius_m: Suchradius in Metern (Standard: 5000, Max: 25000)
+
+    Returns:
+        Liste der gefundenen POIs mit Name, Koordinaten und Entfernung
+    """
+    # Radius begrenzen
+    radius_m = min(max(radius_m, 100), 25000)
+
+    try:
+        elements = await overpass_search_pois(query, lat, lon, radius_m)
+    except Exception as e:
+        return {"error": f"POI-Suche fehlgeschlagen: {str(e)}"}
+
+    # Ergebnisse formatieren
+    pois = []
+    for el in elements:
+        formatted = _format_element(el)
+        if formatted["lat"] and formatted["lon"]:
+            formatted["distance_m"] = round(
+                _haversine(lat, lon, formatted["lat"], formatted["lon"]) * 1000
+            )
+        pois.append(formatted)
+
+    # Nach Entfernung sortieren
+    pois.sort(key=lambda x: x.get("distance_m", 99999))
+
+    return {
+        "query": query,
+        "center": {"lat": lat, "lon": lon},
+        "radius_m": radius_m,
+        "results_count": len(pois),
+        "results": pois[:50],  # Max 50 Ergebnisse
+    }