The AtlasPI MCP server provides comprehensive access to a structured historical geographic database spanning 4,500 BCE to 2024 CE, enabling AI agents to query, explore, and analyze geopolitical history across civilizations.
Entity & Territory Search
Search historical entities (empires, kingdoms, city-states, republics, etc.) by name, year, type, continent, or status
Get full entity details: GeoJSON boundaries, confidence scores, capital coordinates, citations
Batch-fetch up to 100 entities by ID; fuzzy search across scripts/languages
Find similar entities ranked by type, time overlap, duration, and confidence
Geographic & Spatial Queries
Nearby entities: find geopolitical entities closest to a lat/lon in a given year
Where was (reverse geocoding): given coordinates + year, find which historical state controlled that location (with full history option)
Nearest historical city: find historical cities closest to given coordinates
Snapshots & World State
Snapshot at year: all active entities in a given year, filtered by type/continent
World snapshot: active periods, top entities, events, cities, and dynasty chains for a year in one call
What changed between two years: diff of entities that appeared, disappeared, or persisted
Events & History
Search events by year range, type (BATTLE, TREATY, GENOCIDE, REVOLUTION, EPIDEMIC, etc.), status, and known_silence flag
Get event details with entity roles (MAIN_ACTOR, VICTIM, PARTICIPANT, etc.) and ethical notes
Events for a specific entity, geolocated events for map display, and On This Day (by MM-DD across all years)
Timelines, Evolution & Comparisons
Entity evolution: chronological territorial changes, capital moves, and regime transitions
Full unified timeline: events + territory changes + succession transitions in one call
Compare two entities: time overlap, territorial extent, capitals, and sources
Dynasties & Succession Chains
Search chains by type (DYNASTY, SUCCESSION, COLONIAL, IDEOLOGICAL, etc.), region, or year
Get chain details with explicit transition types (CONQUEST, REVOLUTION, DECOLONIZATION, etc.) and violence flags
Find predecessors/successors for any entity
Cities, Trade Routes & Historical Periods
Search historical cities by year, type (CAPITAL, TRADE_HUB, PORT, FORTRESS, etc.), owning entity, or bounding box; colonial renames documented
Search trade routes by year, type (LAND, SEA, CARAVAN, etc.), and slavery involvement
List and query historical periods (Bronze Age, Renaissance, Cold War, etc.); find periods overlapping a year, entity, or event
Stats & Discovery
Dataset statistics: counts, breakdowns by type/continent/status, confidence averages
Random entity discovery, optionally filtered by type, year, continent, or status
Community Feedback
Submit corrections, missing sources, bias reports, or boundary disputes (human-reviewed)
List existing feedback and view aggregate feedback stats
Ethical Design: All data includes confidence scores and status (confirmed/uncertain/disputed). Explicit acquisition_method and transition_type avoid euphemisms for violence. known_silence flags suppressed records, colonial renames are documented, and slavery is flagged on trade routes.
AI agents working with historical geography today face a fragmented landscape: raw shapefiles in Natural Earth, unstructured text in Wikipedia, scattered coordinates in Wikidata, and academic datasets locked behind incompatible formats. None of these were designed for machine consumption.
AtlasPI bridges this gap. It provides a single, structured REST API where an AI agent can ask "What territories existed in the Balkans in 1400?" or "Show me the boundary changes of the Ottoman Empire" and get back clean JSON with GeoJSON boundaries, confidence scores, academic citations, and honest metadata about what is certain and what is disputed.
Historical data is never neutral. Borders were drawn through conquest, names were imposed through colonization, populations were erased through genocide. AtlasPI does not sanitize this complexity -- it structures it, documents it, and makes it queryable.
Related MCP server: Seshat MCP Server
The web UI supports keyboard shortcuts, deep linking (/app?year=1000), continent filtering, time playback animation, dark/light mode, and full i18n (English/Italian). Try it live at atlaspi.it.
# Clone the repository
git clone https://github.com/Soil911/AtlasPI.git
cd AtlasPI
# Install dependencies
pip install -r requirements.txt
# Run the server (auto-seeds the database on first launch)
python run.pyThe API is now live at http://localhost:10100 and the interactive docs at http://localhost:10100/docs.
docker compose up --buildAtlasPI exposes 23 REST endpoints under /v1/. Full interactive documentation is available at /docs (Swagger UI) and /redoc when the server is running.
Method | Endpoint | Description |
|
| Query entities with filters (name, year, status, type) |
|
| Paginated list of all entities |
|
| Full detail for a single entity |
|
| Autocomplete search |
|
| List available entity types |
|
| Dataset statistics |
|
| Available continent/region filters |
|
| Random entity (with optional type/year/status/continent filters) |
|
| Aggregate stats by century, type, continent, status |
|
| Find entities near coordinates (with distance) |
|
| World state at a given year (summary + entities) |
|
| Structured comparison of two entities |
|
| Multi-entity comparison (2-4) with events, chains, overlap |
|
| Entities with overlapping time periods |
|
| Related entities by type or region |
|
| Full chronological evolution of an entity |
|
| Export as GeoJSON FeatureCollection |
|
| Export as CSV |
|
| Export timeline data |
|
| Service health check |
|
| Embeddable map view for iframes |
|
| Interactive entity comparison page |
Search for empires active in 1500 CE:
curl "http://localhost:10100/v1/entity?type=empire&year=1500"Get full details for entity #12:
curl "http://localhost:10100/v1/entities/12"Find entities contemporary to the Roman Empire:
curl "http://localhost:10100/v1/entities/1/contemporaries"Export all entities as GeoJSON:
curl "http://localhost:10100/v1/export/geojson" -o atlas.geojsonFind entities near Rome active in 100 CE:
curl "http://localhost:10100/v1/nearby?lat=41.9&lon=12.5&year=100&radius=500"Snapshot of the world in 1500 CE:
curl "http://localhost:10100/v1/snapshot/1500" | jq '.summary'Compare two entities side by side:
curl "http://localhost:10100/v1/compare/1/5"{
"id": 1,
"name": "Imperium Romanum",
"name_variants": [
{"name": "Roman Empire", "language": "en"},
{"name": "Imperio Romano", "language": "es"}
],
"entity_type": "empire",
"year_start": -753,
"year_end": 476,
"status": "confirmed",
"confidence_score": 0.95,
"capital": {"name": "Roma", "lat": 41.9028, "lon": 12.4964},
"territory_changes": [...],
"sources": [
{"citation": "...", "source_type": "academic"}
]
}How this data is curated — disclosure and correction (2026-07-23)
Curation of non-boundary records (entities, events, cities, rulers, routes, sites) is AI-assisted: LLM research agents propose metadata and candidate citations, an adversarial verification step rejects citations that do not exist or do not support the claim, and the maintainer supervises the pipeline. Records are not systematically reviewed by professional historians. Until the human citation audit (protocol) is published, treat citations as machine-verified, not human-audited. Earlier versions of this documentation said the dataset was "hand-curated" — that wording was inaccurate and has been retired. Full details: METHODOLOGY §2.4 · ETHICS-028 (EN).
1,006 historical entities + 643 historical events spanning 6,500 years of human civilization, backed by 5,000+ academic sources and documenting 2,000+ territory changes. Plus 1,249 archaeological sites, 105 historical rulers, 29 historical languages, 104 dynasty chains, 41 trade routes, 252 historical cities, and 55 historical periods. Events include battles, treaties, epidemics, genocides, colonial violence, massacres, deportations and natural disasters — with ETHICS-007 (no euphemisms) and ETHICS-008 (known_silence flag for erased/suppressed records).
Region | Entities | Examples |
Asia | 195 | Mongol Empire, Qin/Han/Tang/Song/Ming, Tokugawa, Mughal, Khmer, Three Kingdoms |
Europe | 104 | Roman Empire, Byzantine, Kyivan Rus', Hanseatic League, Crusader states, Prussia |
Americas | 85 | Tawantinsuyu (Inca), Aztec, Maya, Haudenosaunee, Empire of Brazil, Taino |
Africa | 78 | Mali, Songhai, Kingdom of Kongo, Great Zimbabwe, Aksum, Zulu, Buganda |
Middle East | 70 | Achaemenid, Ottoman, Abbasid Caliphate, Rashidun, Kingdom of Jerusalem |
Oceania & Pacific | 8 | Aboriginal nations, Maori iwi, Kingdom of Tonga, Hawaiian Kingdom |
15 categories: empire | kingdom | republic | confederation | city-state | dynasty | colony | disputed_territory | sultanate | khanate | principality | duchy | caliphate | federation | city
Earliest entity: 4500 BCE (ancient Mesopotamian civilizations)
Latest entity: 2024 (modern states and disputed territories)
Negative years represent BCE dates (e.g., -753 = 753 BCE)
If you use AtlasPI in research, teaching, or derivative datasets, please cite the project using the Zenodo concept DOI below. The concept DOI always resolves to the latest release — individual versions get their own per-release DOIs on top.
@software{atlaspi_2026,
author = {{AtlasPI Project}},
title = {AtlasPI: A structured historical geographic database for AI agents},
version = {6.13.0},
year = {2026},
doi = {10.5281/zenodo.19581784},
url = {https://doi.org/10.5281/zenodo.19581784}
}AtlasPI Project (2026). AtlasPI: A structured historical geographic database for AI agents, version 6.14.0. Zenodo. https://doi.org/10.5281/zenodo.19581784
Historical data carries the weight of conquest, displacement, and erasure. AtlasPI is built on four principles that govern every data decision:
Historical records include conquest, genocide, forced deportation, and cultural erasure. These facts are represented with precision, never sanitized. If a territory was seized by force, the acquisition_method field says so. If a population was decimated, the data shows it with sources. If a geographic name was imposed by erasing the original, both names are present.
Contested borders show all known versions, with dates and sources. Place names include the original local form alongside names in other relevant languages. Academic disputes are made explicit, not resolved by fiat. The database does not arbitrate history -- it documents it.
Every record carries a confidence_score from 0.0 to 1.0. Every data point includes sources[] with primary source citations. Records scoring below 0.5 are marked as status: "uncertain" (enforced at the data layer — see ETHICS-013; the distinct status: "disputed" is reserved for contested territories, ETHICS-003). An uncertain datum honestly labeled is more valuable than a fabricated certainty.
Place names use the local-language form as the primary name. Sources include non-Western historiography where available. Colonial conquests are documented from the perspective of the colonized, not only the colonizers.
These principles are enforced through automated ethical tests, documented decisions in
docs/ethics/, and# ETHICS:comments throughout the codebase. See CLAUDE.md for the full governance framework.
Component | Technology |
API | FastAPI (Python 3.11+) |
Database (dev) | SQLite |
Database (prod) | PostgreSQL + PostGIS |
Validation | Pydantic v2 |
Rate Limiting | SlowAPI |
Frontend | Vanilla JS + Leaflet.js |
Containerization | Docker (multi-stage build) |
CI | GitHub Actions (lint + test + build) |
atlaspi/
src/
api/ # FastAPI routes, schemas, error handling
db/ # SQLAlchemy models, database setup, seed data
ingestion/ # Data import pipelines, boundary extraction
validation/ # Confidence scoring engine
static/ # Web UI (HTML, CSS, JS)
data/
entities/ # Source entity data (JSON)
raw/ # Original unmodified source data
processed/ # Normalized data
tests/ # 260 tests: technical, ethical, security, performance, data quality
docs/
adr/ # Architecture Decision Records
ethics/ # Documented ethical decisions (ETHICS-001, 002, 003...)Dual database support: SQLite for zero-config local development, PostgreSQL + PostGIS for production spatial queries.
Auto-seeding: The database populates itself on first launch from JSON entity files -- no manual migration needed.
GZip compression, CORS, rate limiting (60 req/min), and security headers enabled by default.
Structured logging: JSON format in production, human-readable in development.
The test suite covers five dimensions:
# Run all tests
pytest
# Run with verbose output
pytest -vCategory | What it verifies |
Technical | API responses, pagination, input validation, edge cases |
Ethical | ETHICS-001/002/003 compliance, disputed territory handling, confidence thresholds |
Security | CORS, security headers, structured error responses, rate limiting |
Performance | All endpoints respond in < 500ms |
Data Quality | Source completeness, regional diversity, entity type coverage |
Contributions are welcome. Before you start:
Read CLAUDE.md -- it contains the project's core values and development conventions.
Check docs/ethics/ -- understand the ethical decisions already made.
Check docs/adr/ -- understand the architectural decisions already made.
Code is written in English; documentation in Italian (except this README).
Every function touching sensitive historical data must include an # ETHICS: comment explaining the design choice.
Tests must cover ethical edge cases, not only technical ones.
New entity data must include sources[] with verifiable academic citations.
Disputed territories must have confidence_score <= 0.7 and status: "disputed".
Entity data lives in data/entities/ as JSON files. Each entity requires:
Primary name in the original/local language
At least one academic source
A confidence score reflecting source reliability
Territory changes with dated boundaries where available
# Install with dev dependencies
pip install -e ".[dev]"
# Lint
ruff check src/ tests/
# Test
pytest -vSee ROADMAP.md for the full development plan. Key upcoming milestones:
PostgreSQL + PostGIS spatial queries in production
Full GeoJSON boundary coverage for all entities
Wikidata/OpenStreetMap ingestion pipelines
Premium API tier with higher rate limits
Hosted instance with public access
If you use AtlasPI in academic work, teaching, or derivative datasets, please cite it. A machine-readable CITATION.cff is provided in the repository root and is recognized by GitHub, Zenodo, Zotero, and most reference managers.
Ramadani, C. (2026). AtlasPI: A structured historical geographic database for AI agents (Version 6.1.2) [Software]. CRA. https://doi.org/10.5281/zenodo.19581784
@software{ramadani_atlaspi_2026,
author = {Ramadani, Clirim},
title = {AtlasPI: A structured historical geographic database for AI agents},
version = {6.1.2},
year = {2026},
publisher = {CRA},
doi = {10.5281/zenodo.19581784},
url = {https://doi.org/10.5281/zenodo.19581784},
note = {Live instance: https://atlaspi.it. Concept DOI (all versions): 10.5281/zenodo.19581784. Version v6.1.2 DOI: 10.5281/zenodo.19581785.}
}AtlasPI derives its geographic boundaries from two upstream datasets. If your work depends on spatial precision, please also cite them directly:
Natural Earth (public domain) — post-1800 modern administrative boundaries. https://www.naturalearthdata.com/
aourednik/historical-basemaps (CC BY 4.0) — pre-1800 historical world timestamps. Ourednik, A. historical-basemaps. https://github.com/aourednik/historical-basemaps
For full methodology on how boundaries are assigned, matched, and confidence-scored, see docs/METHODOLOGY.md.
The dataset has a permanent DOI minted by Zenodo: 10.5281/zenodo.19581784 (concept DOI, always resolves to the latest version). Every tagged release mints a new version DOI; see the Zenodo record for v6.1.2 specifically. Deposition metadata is in .zenodo.json.
AtlasPI follows an open core model.
The core project -- API, data models, ethical framework, and documentation -- is released under the Apache License 2.0.
Imported datasets retain their original licenses. Every source is tracked and attributed. Premium components (hosted services, curated datasets, enterprise features) are maintained separately from the open source core.
See LICENSE for the full Apache License 2.0 text and NOTICE for third-party attributions.
AtlasPI builds on the work of:
Natural Earth -- public domain vector map data for modern boundaries
aourednik/historical-basemaps -- historical world boundary data
OpenStreetMap -- geographic data under ODbL
Wikidata -- structured knowledge base under CC0
And the countless historians, cartographers, and researchers whose work makes structured historical geography possible.
Confronta due entita' storiche dato il loro id numerico. Ritorna un report strutturato con sovrapposizione temporale, differenze di estensione territoriale, diversita' di status, capitali e fonti. Utile per domande comparative tipo 'paragona Roma Repubblicana e Impero Bizantino' o 'che differenze ci sono tra il Sacro Romano Impero e l'Impero Carolingio?'.
Inputs: id1 (required), id2 (required).
Restituisce statistiche aggregate del dataset AtlasPI: numero totale di entita', breakdown per tipo, distribuzione per status (confirmed / uncertain / disputed), distribuzione per continente, intervallo temporale coperto (year_range), confidence_score medio, numero totale di fonti citate e di cambi territoriali. Utile come tool di scoperta iniziale per capire la copertura del dataset prima di formulare query specifiche.
Inputs: no named parameters.
Restituisce le catene in cui l'entità data ha un predecessore (sequence_order > 0), insieme al predecessore immediato, transition_year, transition_type, is_violent e ethical_notes della transizione CHE HA PORTATO A questa entità. Usa per domande tipo 'che entità ha preceduto la Repubblica di Turchia?' (→ Ottoman Empire, transition 1923 REVOLUTION).
Inputs: entity_id (required).
Restituisce le catene in cui l'entità data ha un successore, insieme al successore immediato, transition_year, transition_type, is_violent e ethical_notes della transizione CHE HA PORTATO DA questa entità all'entità successiva. Usa per domande tipo 'cosa è venuto dopo Tawantinsuyu?' (→ Viceroyalty of Peru, transition 1542 CONQUEST).
Inputs: entity_id (required).
Ritorna le epoche storiche in cui è avvenuto un evento specifico. Es. event_id=123 (Battle of Tours, 732) → [Early Middle Ages (europe), Islamic Golden Age (near_east)].
Inputs: event_id (required), region.
Restituisce le date (MM-DD) che hanno almeno un evento nel dataset. Usa PRIMA di on_this_day per sapere se una data restituirà risultati, oppure per suggerire date 'interessanti' all'utente (es. 'In quali giorni dell'anno ci sono più eventi storici?'). La risposta include unique_dates (quante date uniche), coverage_pct (% dell'anno coperta), e la lista completa dates con mm_dd + event_count. Non richiede parametri — è un metadato del dataset.
Inputs: no named parameters.
Restituisce tutti gli eventi storici in cui una data entità compare (fondazione, conquiste, eventi subiti, dissoluzione). Filtro opzionale su role (MAIN_ACTOR, VICTIM, ecc.). Usa questo tool dopo get_entity/search_entities per ricostruire la storia eventuale di una specifica entità (es. 'quali eventi ha subito l'Impero Ottomano?'). Distingue tra ruoli attivi (conquiste operate) e subiti (conquiste ricevute, genocidi, colonizzazioni).
Inputs: entity_id (required), role.
Recupera gli eventi storici geolocalizzati attorno a un dato anno, ottimizzato per la visualizzazione su mappa. Restituisce un payload leggero (10 campi per evento) con solo eventi che hanno coordinate. La finestra temporale si auto-espande per epoche antiche: ±50 anni per anni < -1000 a.C., ±25 per il periodo classico, ±10 per l'età moderna. Usa questo tool quando l'utente chiede 'cosa è successo vicino a [luogo] nel [anno]?' o per popolare una visualizzazione mappa con eventi. Non include description/sources — usa get_event per i dettagli di un singolo evento.
Inputs: year (required), limit, window.
Counters aggregati sul feedback: totale, by_status, by_category, by_submitter_type, last_24h, last_7d. Utile per capire l'attivita' della community e identificare le categorie piu' calde.
Inputs: no named parameters.
Trova entita' storiche simili a quella specificata, ordinate per punteggio di similarita' (0.0-1.0). Il punteggio considera: tipo di entita' (35%), sovrapposizione temporale (30%), durata simile (15%), confidence simile (10%), stesso status (10%). Usa questo tool quando l'utente chiede 'quali imperi erano simili a Roma?' o 'trova stati paragonabili al Sacro Romano Impero' o 'suggerisci paralleli storici per l'Impero Mongolo'. Il risultato include id, nome, tipo, periodo e punteggio per ogni entita' simile.
Inputs: entity_id (required), limit, min_score.
Restituisce la timeline unificata di un'entità: eventi storici (via EventEntityLink), cambi territoriali e transizioni di catene successorie (predecessori + successori) in un unico stream ordinato cronologicamente. Ogni voce ha un campo discriminatore 'kind' fra 'event', 'territory_change' e 'chain_transition'. Usa questo tool invece di chiamare get_evolution + events_for_entity + entity_predecessors + entity_successors separatamente quando l'utente chiede la storia completa di un'entità (es. 'raccontami tutta la storia dell'Impero Romano d'Oriente'). Ritorna counts per ogni kind piu' lo stream unificato.
Inputs: entity_id (required), include_entity_links.
Ricerca approssimata (fuzzy) sui nomi delle entità storiche — tollera errori di spelling, trascrizioni diverse e script differenti. Usa difflib.SequenceMatcher a livello di caratteri Unicode, quindi funziona anche cross-script (latino, cirillico, arabo, cinese, devanagari, ecc.). Esempio: q='safavid' trova 'دولت صفویه' (script arabo), q='Constantinople' trova 'Κωνσταντινούπολις' (script greco). Preferisci questo tool quando search_entities non trova risultati per via di translitterazione non standard o spelling approssimativo.
Inputs: q (required), limit, min_score.
Dettaglio di una catena successoria con tutti i link in ordine cronologico. Ogni link ha sequence_order, entità di riferimento, transition_year, transition_type (ETHICS-002: esplicito, no eufemismi), is_violent, description e ethical_notes specifiche per la singola transizione. Usa dopo search_chains.
Inputs: chain_id (required).
Dettaglio di una città storica: nome originale, varianti linguistiche e storiche (ETHICS-009: rename coloniali/imperiali documentati — es. Konstantinoupolis → Istanbul, Königsberg → Kaliningrad, Tenochtitlan → Ciudad de México, Calcutta → Kolkata), coordinate, tipo, population_peak, fonti, entità politica corrente. Usa dopo search_cities per approfondire.
Inputs: city_id (required).
Dettaglio completo di un evento storico dato il suo id: tipo, anno, descrizione, entità coinvolte con ruolo esplicito (MAIN_ACTOR, VICTIM, PARTICIPANT, AFFECTED, WITNESS, FOUNDED, DISSOLVED), fonti con page/confidence, ethical_notes. ETHICS-007: il main_actor è sempre presente — la voce attiva ('chi ha fatto cosa a chi') è obbligatoria per eventi di violenza.
Inputs: event_id (required).
Restituisce la timeline dei cambi territoriali di una entita': annessioni, perdite di territorio, cambi di capitale, transizioni di regime, eventi di scissione o unificazione. Ogni evento ha anno, descrizione, fonte e (quando disponibile) acquisition_method per documentare se un territorio fu acquisito per conquista, matrimonio dinastico, trattato, ecc. Importante per ricostruire l'arco storico di un'entita' nel tempo.
Inputs: entity_id (required).
Dettaglio completo di un periodo storico dato il suo ID numerico. Include description, historiographic_note (controversie accademiche), alternative_names (es. 'Dark Ages' per 'Early Middle Ages') e sources bibliografiche.
Inputs: period_id (required).
Dettaglio di un periodo dato lo slug URL-friendly (es. 'bronze-age', 'edo-period', 'islamic-golden-age'). Più leggibile di get_historical_period quando l'ID non è noto.
Inputs: slug (required).
Dettaglio di una rotta commerciale: nome originale, tipo geografico, intervallo temporale, waypoints (città attraversate in ordine) con coordinate, commodities principali, flag involves_slavery, geometry_geojson per visualizzazione, ethical_notes dettagliate. ETHICS-010: le rotte della tratta atlantica documentano le stime di Middle Passage (~1.8M morti su 12.5M embarcati).
Inputs: route_id (required).
Lista i feedback gia' sottomessi da altri agenti/umani. Utile per cross-validation: prima di sottomettere un nuovo feedback, controlla se qualcuno ha gia' segnalato lo stesso problema.
Filtra per status (pending, accepted, rejected, ...), category, entity_id, o submitter_type. Trasparenza pubblica.
Inputs: limit, offset, status, category, +2 more.
Lista epoche storiche strutturate (Bronze Age, Classical Antiquity, Edo Period, Cold War, ecc.). Ogni periodo ha scope regionale esplicito (es. 'Middle Ages' è europeo, non globale) e confidence_score. Filtrabile per region, period_type (age/era/period/dynasty/epoch), anno (ritorna periodi che includono quell'anno), status. USA per: inquadrare un anno o entità nel contesto storico, rispondere a domande tipo 'In che epoca era il 1200 in Europa?', 'Quali periodi esistono in Giappone?'. ETHICS: le periodizzazioni sono costrutti storiografici; il campo historiographic_note documenta controversie accademiche.
Inputs: year, limit, offset, region, +2 more.
Trova le città storiche più vicine a una coppia di coordinate (latitudine, longitudine), opzionalmente filtrate per anno di attività e tipo (CAPITAL, TRADE_HUB, ecc.). Calcola la distanza haversine client-side e ordina per distanza crescente. Usa per domande tipo 'che città c'erano vicino a 41.9, 12.5 nel 100 d.C.?' (città vicino Roma) o 'qual è il trade hub più vicino a Venezia nel 1400?'. Nota: questo tool trova CITTÀ storiche (dataset separato da GeoEntity) — per capitali di imperi/regni usa nearby_entities.
Inputs: lat (required), lon (required), year, limit, +2 more.
Restituisce gli eventi storici avvenuti in una specifica data del calendario (mese e giorno), attraverso tutti gli anni nel dataset. Formato: MM-DD (es. '07-04' per il 4 luglio, '10-12' per il 12 ottobre). Utile per curiosità storiche, efemeridi, quiz, contenuti 'accadde oggi'. Esempio: on_this_day('10-12') potrebbe restituire lo sbarco di Colombo (1492) e il giorno della scoperta del Nuovo Mondo.
Inputs: mm_dd (required).
Restituisce una entita' storica casuale, opzionalmente filtrata per tipo, anno, continente o status. Pensato per esplorazione, suggerimenti, generazione di curiosita' storiche o per permettere all'agente di proporre 'lo sapevi che...' contestuali. Esempio: random_entity(type='khanate', continent='Asia') ritorna un khanato asiatico a caso.
Inputs: type, year, status, continent.
Cerca catene successorie/dinastiche/coloniali con filtri su chain_type (DYNASTY / SUCCESSION / RESTORATION / COLONIAL / IDEOLOGICAL / OTHER), region, year (almeno un'entità della catena attiva in quell'anno), status. ETHICS-002: ogni link ha transition_type esplicito (CONQUEST / REVOLUTION / REFORM / SUCCESSION / DECOLONIZATION / PARTITION / UNIFICATION / DISSOLUTION / ANNEXATION) — non esiste 'succession' generico che maschera violenze. ETHICS-003: chain_type=IDEOLOGICAL (es. Sacrum Imperium Romanum → Deutsches Kaiserreich → Deutsches Reich) porta avvertimento che la continuità self-proclaimed non implica legittimità.
Inputs: year, limit, offset, region, +2 more.
Cerca città storiche con filtri su anno di attività, tipo funzionale (CAPITAL, TRADE_HUB, RELIGIOUS_CENTER, FORTRESS, PORT, ACADEMIC_CENTER, INDUSTRIAL_CENTER, MULTI_PURPOSE), entità politica di appartenenza, bbox geografica. Una città è separata dalla capital_* di GeoEntity perché può sopravvivere più entità politiche (es. Costantinopoli/Istanbul attraversa Bizantino → Ottomano → Repubblica di Turchia).
Inputs: bbox, year, limit, offset, +3 more.
Cerca eventi storici con filtri su anno, tipo, status e silenzio documentato. ETHICS-007: i tipi usano termini espliciti — GENOCIDE, COLONIAL_VIOLENCE, ETHNIC_CLEANSING, MASSACRE, DEPORTATION — senza eufemismi. Per domande tipo 'quali genocidi sono registrati nel XX secolo?' (event_type='GENOCIDE', year_min=1900, year_max=2000). ETHICS-008: known_silence=true filtra eventi storicamente insabbiati (es. genocidio armeno nella storiografia turca).
Inputs: limit, offset, status, year_max, +3 more.
Cerca rotte commerciali storiche con filtri su anno di attività, tipo geografico (LAND, SEA, RIVER, CARAVAN, MIXED) e involves_slavery. ETHICS-010: involves_slavery=true restituisce le rotte che trafficavano esseri umani schiavizzati come merce primaria (Trans-Atlantic, Trans-Saharan Slave, Indian Ocean Slave Route). Il flag è esplicito perché la distinzione è eticamente rilevante. Nota: 'Silk Road' è attribuzione 1877 di Richthofen, non un'auto-designazione delle carovane storiche.
Inputs: year, limit, offset, status, +2 more.
Restituisce uno snapshot del mondo in un dato anno: tutte le entita' geopolitiche attive in quell'anno (year_start <= anno <= year_end), con possibilita' di filtrare per tipo o continente. Usa questo tool per domande del tipo 'che mappa politica c'era nel 300 a.C.?' o 'quali regni esistevano in Africa nel 1500?'. Ricorda: gli anni negativi sono a.C.
Inputs: year (required), type, continent.
Sottometti un feedback strutturato sul database AtlasPI: correzioni di dati, citazioni mancanti, polygon imprecisi, bias report, ecc. Usa questo tool quando hai informazioni VERIFICATE che contraddicono i dati attuali, oppure quando vuoi suggerire una fonte accademica non ancora presente.
Il feedback non modifica direttamente i dati: va in stato 'pending' e richiede review umana per contenuti storici (vedi ETHICS).
Quando usarlo:
Trovi una data sbagliata supportata da una fonte (es. year_end di una dinastia)
Vuoi aggiungere una citation accademica a un'entita'
Noti un bias di rappresentazione (es. nome coloniale come primario)
Identifichi un'entita' storica mancante dal database
Best practice: fornisci sempre 'citation' (la fonte) e 'reasoning' (1-3 frasi che spiegano perche').
Inputs: category (required), submitter_type (required), city_id, citation, +8 more.
Diff macro-storico del mondo tra due anni: ritorna le entità apparse fra year1 e year2, quelle scomparse, e gli id di quelle persistenti. Opzionalmente filtra per tipo o continente. Usa per domande tipo 'cosa è cambiato nel Mediterraneo tra il 300 a.C. e il 100 d.C.?' o 'quali imperi sono apparsi tra il 1800 e il 1900 in Africa?'. È composizione client-side di due snapshot — più economico di due chiamate separate se servono solo id+nomi.
Inputs: year1 (required), year2 (required), type, continent.
v6.34: reverse-geocoding temporale. Dato un punto geografico (lat, lon) e un anno, restituisce tutte le entita' storiche il cui boundary_geojson contiene quel punto in quell'anno. Primary use case: GENEALOGIA / DIASPORA ("Il mio bisnonno da Leopoli nel 1905 — sotto che stato era?"). Due modalita': (1) year-specific: entita' che controllavano il punto in un anno; (2) include_history=true: timeline completa di TUTTI gli imperi/ regni che hanno mai controllato quel punto, ordinati cronologicamente. Se il punto e' in territorio contestato (ETHICS-003), ritorna tutte le entita' che lo rivendicano con status='disputed', senza arbitrare la sovranita'. Usa per domande tipo 'chi comandava a Istanbul nel 1500?', 'che impero controllava Berlino nel 1945?', 'storia di Gerusalemme dal 1000 a.C. a oggi' (include_history=true).
Inputs: lat (required), lon (required), year, include_history.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 32 tools
Every tool has a clearly distinct purpose. Tools covering similar domains (e.g., events) are split into search, detail, entity-specific, map-optimized, date-specific, and coverage metadata, each with unique functionality and inputs. No two tools serve the same role.
All 32 tools follow a consistent verb_noun pattern in snake_case, such as get_route, search_events, list_feedback. Naming is predictable and descriptive, making it easy to infer a tool's function from its name without ambiguity.
32 tools is slightly high but well justified by the comprehensive and multi-faceted domain (entities, events, cities, routes, chains, feedback). Each tool serves a specific need, and the set covers exploration, search, detail, comparison, and metadata operations without unnecessary redundancy.
The tool surface is remarkably complete for a historical atlas: CRUD-like operations for entities, events, cities, routes, and chains are present, along with specialized tools for timeline, comparison, fuzzy search, feedback, and dataset statistics. No obvious gaps for standard historical queries.
Geocoding, routing, isochrones, traffic, weather, and place search for AI agents. 19 MCP tools.
Patterns for designing and reviewing AI skills, agents, and multi-agent workflows. Find guidance on context economy, delegation, verification, and tool design; inspect claims, worked examples, maturity labels, and source references. Five read-only tools let agents discover relevant patterns, compare concise cards, read specific sections, and explore relationships. Hosted Streamable HTTP at https://agentic-atlas.dev/mcp/ — no installation, account, or API key required. Browse the atlas at https://agentic-atlas.dev/.
Historical borders and dated map events with source attribution and coverage limits.
Free public MCP for AI agents — 193 tools, 44 workflows. No API key.
