* Package name : pelias
Version :
Upstream Author : Peter Johnson pelias.team@gmail.com
* URL : https://github.com/pelias/pelias
* License : MIT
Programming Lang: JavaScript
Description : Pelias is a modular open-source geocoder using Elasticsearch.
metapackage for:
https://github.com/pelias/schema/
https://github.com/pelias/api/
https://github.com/pelias/placeholder
https://github.com/pelias/pip-service
https://github.com/pelias/libpostal-service
https://github.com/pelias/interpolation/
https://github.com/pelias/polylines
https://github.com/pelias/openstreetmap/
https://github.com/pelias/whosonfirst/
https://github.com/pelias/geonames/
https://github.com/pelias/csv-importer
https://github.com/pelias/openaddresses/
A modular, open-source geocoder built on top of Elasticsearch for fast and accurate global search.
What are the most interesting features of Pelias?
Completely open-source and MIT licensed
A powerful data import architecture: Pelias supports many open-data projects out of the box but also works great with private data
Support for searching and displaying results in many languages
Fast and accurate autocomplete for user-facing geocoding
Support for many result types: addresses, venues, cities, countries, and more
Modular design, so you don't need to be an expert in everything to make changes
Easy installation with minimal external dependencies
What are the main goals of the Pelias project?
Provide accurate search results
Work equally well for a small city and the entire planet
Be highly configurable, so different use cases can be handled easily and efficiently
Provide a friendly, welcoming, helpful community that takes input from people all over the world
Where did Pelias come from?
Pelias was created in 2014 as an early project at Mapzen. After Mapzen's shutdown in 2017, Pelias is now part of the Linux Foundation.
How does it work?
Like any geocoder, Pelias combines full text search techniques with knowledge of geography to quickly search over many millions of records, each representing some sort of location on Earth.
The Pelias architecture has three main components and several smaller pieces.
Data importers
The importers filter, normalize, and ingest geographic datasets into the Pelias database. Currently there are six officially supported importers:
OpenStreetMap: supports importing nodes and ways from OpenStreetMap
OpenAddresses: supports importing the hundreds of millions of global addresses collected from various authoritative government sources by OpenAddresses
Who's on First: supports importing admin areas and venues from Who's on First
Geonames: supports importing admin records and venues from Geonames
Polylines: supports any data in the Google Polyline format. It's mainly used to import roads from OpenStreetMap
CSV: supports importing any data in CSV format, which is great for custom data or proprietary data
We are always discussing supporting additional datasets. Pelias users can also write their own importers, for example to import proprietary data into your own instance of Pelias.
Database
The underlying datastore that does most of the query heavy-lifting and powers our search results. We use Elasticsearch. Currently version 6 is supported, with plans to support Elasticsearch 7 soon.
We've built a tool called pelias-schema that sets up Elasticsearch indices properly for Pelias.
Frontend services
This is where the actual geocoding process happens, and includes the components that users interact with when performing geocoding queries. The services are:
API: The API service defines the Pelias API, and talks to Elasticsearch or other services as needed to perform queries.
Placeholder: A service built specifically to capture the relationship between administrative areas (a catch-all term meaning anything like a city, state, country, etc). Elasticsearch does not handle relational data very well, so we built Placeholder specifically to manage this piece.
PIP: For reverse geocoding, it's important to be able to perform point-in-polygon(PIP) calculations quickly. The PIP service is is very good at quickly determining which admin area polygons a given point lies in.
Libpostal: Pelias uses the libpostal project for parsing addresses using the power of machine learning. We use a Go service built by the Who's on First team to make this happen quickly and efficiently.
Interpolation: This service knows all about addresses and streets. With that knowledge, it is able to supplement the known addresses that are stored directly in Elasticsearch and return fairly accurate estimated address results for many more queries than would otherwise be possible.
Dependencies
These are software projects that are not used directly but are used by other components of Pelias.
There are lots of these, but here are some important ones:
model: provide a single library for creating documents that fit the Pelias Elasticsearch schema. This is a core component of our flexible importer architecture
wof-admin-lookup: A library for performing administrative lookup using point-in-polygon math. Previously included in each of the importers but now only used by the PIP service.
query: This is where most of our actual Elasticsearch query generation happens.
config: Pelias is very configurable, and all of it is driven from a single JSON file which we call pelias.json. This package provides a library for reading, validating, and working with this configuration. It is used by almost every other Pelias component
dbclient: A Node.js stream library for quickly and efficiently importing records into Elasticsearch