Architecture
Mera splits work between your phone and a few services. The phone holds what's personal. The services hold news, accounts and billing.
The parts
| Part | What it does | Source |
|---|---|---|
| Mera app | Holds your facts, topics, feed and chats. Chooses and ranks. Runs the encryption. | Source-available |
| Inference gateway | Checks your session and passes encrypted AI requests to NEAR AI. | Repository public |
| NEAR AI | Runs AI models inside secure hardware. Operated by NEAR AI. | Third party |
| Auth service | Signs phones in, holds accounts, serves the public publication list. | Private |
| GraphQL API | Takes topic text, returns articles. Serves World, Search and publication pages. | Private |
| News preparation | Reads publishers' feeds and prepares articles. | Private |
Mera's services run on Google Cloud. The public hostnames are graphql.mera.news, auth.mera.news and inference.mera.news. This website is served separately and takes no part in the app's data flow.
How a feed update works
- Topics. Your phone turns your facts into short topic phrases, on the phone or in Private cloud. The phrases are stored on the phone.
- Request. The phone sends those phrases to the GraphQL API, with any countries you follow for top headlines.
- Candidates. The server answers with article identifiers.
- Articles. The phone asks for the articles it doesn't already have, by identifier. The server counts how many it delivered that day, for your plan. It doesn't store which ones.
- Ranking. Your phone ranks each candidate against your profile and writes a short note, on the phone or in Private cloud.
- Feed. The results are saved on the phone. The server never sees a score or a note.
When you tap through, the publisher's page opens in an in-app browser.
Silent push notifications can wake the app to do this in the background. In Private cloud, the phone prepares and encrypts the work itself. With On this phone, ranking happens when you open the app.
The server boundary
The steps that prepare news on the server aren't documented here. Only what crosses the boundary is.
| Direction | At the server boundary |
|---|---|
| Into Mera | Publishers' RSS and Atom feeds |
| In from your phone | Topic text, country scopes, paging cursors, article identifiers |
| Out to your phone | Article identifiers, then article records such as headline, link, image address, publication, country, language and the feed's description, which is used to judge relevance and never shown |
The feed request format has no field for your facts, places or topic weights, and widening it would be a privacy change. A topic phrase can still name a place, as "Amsterdam local news" does. You can read the format in schema.gql in the app repository.
How an AI request works
- The phone fetches the public key of the model's secure environment.
- It encrypts the message content to that key on the phone.
- It sends the request to the gateway with your session token.
- The gateway checks the token and forwards the request to NEAR AI without reading the content.
- The secure environment decrypts, runs the model and encrypts the reply back to your phone.
Private inference covers this in depth, including what isn't checked.
Other requests that reach a server
A few features send readable text or an article identifier, because of what they do:
- Web search in chat sends search words through the gateway to a search provider.
- Search in the app sends what you type to the GraphQL API.
- Place search sends what you type to find a city.
- Fact checks send short search words or an article identifier.
- Opening an article asks for its related coverage. From World, Search, a shared link or a followed story, it also fetches the article by identifier.
What's stored where covers each one.
What the server is built not to do
- No collection links a user to a topic. Topics are text-keyed and have no owner field.
- No collection links a user to an article.
- No behavioural analytics run in the app or on the server. Mera's internal numbers come only from what it already keeps to run the product, such as daily usage counts.
These are design rules for code that isn't public yet. See Known gaps.