# Databricks Genie Agent and Databricks Genie MCP: Two Ways to Add Public Reviews

> The Genie Agent docs list 9 built-in MCP connectors. Land Trustpilot, Google Play and Reddit reviews in Delta for $0.003334 per daily run.

- Canonical page: https://everyinfra.com/en/blog/databricks-genie-agent-public-social-review-data
- Published: 2026-11-14T14:56:00+08:00 · Fact-checked: 2026-11-14T14:30:00+08:00

Databricks released the second-generation Genie on November 11, 2026. Your sales and ticket tables already live in Unity Catalog. How can Genie also see what customers say in public on Trustpilot, Google Play and Reddit?

We read the official Databricks press release, blog posts and the November docs. Then we called three EveryInfra capabilities for one public brand, HelloFresh, in three rounds on November 14. This article gives two routes that work today, a table design, a dedupe method and the daily cost. We did not run anything in a Databricks workspace. All Databricks SQL and steps are marked "configuration example."

> **Key points**
>
> - The Genie Agents docs mark MCP connectors as Beta. The docs list 9 built-in Databricks connectors and do not mention custom MCP (read on November 14; page updated November 9). The custom MCP docs are on the Genie One chat side. To use public reviews in a Genie Agent, the route that we can confirm is to land them in a Unity Catalog table first.
> - A daily job that calls `trustpilot/reviews`, `google_play/reviews` and `reddit/subreddit_posts` once each cost $0.003334 per run in our test, about $0.10 per 30 days. Pulls 20 and 40 minutes later returned 0 new IDs from all three sources.
> - One brand on one day: we read the 50 newest HelloFresh Trustpilot reviews. 6 of 7 organic reviews had 1 or 2 stars, and 8 of 43 invited reviews did. The sample is small. Still, describe the split in the column comment, so that an average does not hide the organic complaints.
> - One wide table with a `dedupe_key` and a `MERGE` catches new reviews and company replies that arrive later. Match only on the dedupe key, and put the 60-day look-back on the staging side, so that old reviews are not inserted again.

## What Databricks shipped with the second-generation Genie on November 11

Databricks announced the second generation of Genie in a [press release dated November 11, 2026](https://www.databricks.com/company/newsroom/press-releases/databricks-launches-new-always-genie-autonomous-ai-complex). The release calls Genie an always-on, autonomous agent for enterprise work. You give it a goal. It splits the work, hands parts to subagents and follows up on missing inputs.

When it needs a decision, it contacts you through a priority inbox or email.

The "Availability" paragraph of the release says this: Genie and Genie Ontology are generally available to all customers. Genie Search, Ontology Manager and the new always-on Genie are "coming soon to preview and beta programs."

So on November 14, a normal workspace can use three parts: Genie One chat, Genie Agents (formerly Genie Spaces) and the Genie One MCP server. The always-on job layer needs a preview slot. This difference matters for planning. A design that depends on a long-running Genie job is a design for next quarter. A design that depends on tables, scheduled jobs and Genie Agents works today.

The [product blog from the same day](https://www.databricks.com/blog/new-genie-autonomous-ai-complex-enterprise-work) adds two details that matter here. First, a long-running Genie job can run on a schedule or start from a trigger. The blog gives a trigger example: a metric dips, or more than 10 customers ask for the same feature. Second, Genie can use built-in MCP connectors for Slack, Jira and GitHub. It can also reach other systems "through custom MCP".

Note that the blog describes the new always-on Genie, which is not open yet. For what a Genie Agent can attach today, read the Genie Agents docs that we cite below.

We picked HelloFresh as the public brand for our tests. It has enough public content on Trustpilot, Google Play and Reddit to compare three source types side by side. HelloFresh has no business relationship with EveryInfra. We use only reviews and posts that anyone can see in public.

| Item | What the source says | Stage on Nov 14 | Source |
| --- | --- | --- | --- |
| Second-generation Genie (always-on) | Takes a goal, splits work, uses subagents, inbox and email | Coming to preview and beta | Press release, Nov 11 |
| Genie, Genie Ontology | Context layer of definitions, metrics, people and processes | Generally available | Press release, Nov 11 |
| Genie Search | 100+ sources; can query apps live through MCP | Coming to preview and beta | Press release, Nov 11 |
| Genie One MCP | Exposes Genie to outside agents as an MCP service | Generally available since Sep 22 | Databricks blog and docs |
| MCP connectors in Genie Agents | Agent mode calls built-in Databricks connectors | Beta; admin turns it on in Previews | Docs |
| Custom MCP services (external MCP) | Register in Unity Gateway, then use in Genie One | Documented | Docs |

## Databricks Genie MCP means three different things

In the official docs, the phrase "databricks genie mcp" covers three different setups. One opens Genie to outside agents. The others let Genie call outside services. Pick the right one before you connect outside data.

The first route makes Genie an MCP server that other agents call. The [Genie One MCP server docs](https://docs.databricks.com/aws/en/agents/mcp-tools/genie-mcp) give its address as `https://<workspace-hostname>/ai-gateway/mcp-services/system.ai.genie_one_mcp?o=<workspace-id>`. The caller needs `EXECUTE` on `system.ai.genie_one_mcp`, which is an `mcp_service` securable. The tools are `genie_ask`, `genie_poll_response` and `genie_get_query_result`, plus `view_ask` on clients that support MCP Apps.

The [GA blog post from September 22, 2026](https://www.databricks.com/blog/genie-one-mcp-now-generally-available) says that agents such as Claude, ChatGPT and Cursor can treat Genie as a data-aware coworker. The docs also say that the old Beta endpoint `/api/2.0/mcp/genie` reaches end of life on November 30, 2026. This route answers "how do outside agents ask about data in Databricks." It does not bring outside data in.

The second route lets Genie One call an external MCP server. The [Genie One external applications docs](https://docs.databricks.com/aws/en/genie-one/external-sources) list three kinds of servers. There are built-in Databricks connectors, MCP servers from Databricks Marketplace, and "custom MCP services" that your organization registers in Unity Catalog. The [external MCP servers page](https://docs.databricks.com/aws/en/ai-gateway/register-mcp-service) gives the registration steps.

The server must support the [Streamable HTTP transport](https://modelcontextprotocol.io/specification/latest/basic/transports/streamable-http). In Unity Gateway you open MCPs, choose "Connect an existing MCP server," and create an HTTP connection with the URL and credentials. The EveryInfra remote MCP at `https://api.everyinfra.com/mcp` uses Streamable HTTP with an API key in an `Authorization: Bearer` header. That matches "Bearer token," the first of five auth types on the [HTTP connection page](https://docs.databricks.com/aws/en/query-federation/http).

The third route lets Genie Agents call connectors in Agent mode. The [Genie Agents MCP page](https://docs.databricks.com/aws/en/genie-agents/external-tools) shows a last-updated date of November 9, 2026. It marks the feature as Beta. A workspace admin must turn on "MCP tools in Genie Agents" on the Previews page.

The page lists nine connectors: Google Drive, Gmail, Google Calendar, Microsoft 365, Atlassian, Asana, Glean, Slack and GitHub. All nine are built-in Databricks connectors. The docs list these 9 built-in connectors and do not mention custom MCP services (read on November 14, 2026). The November 12 release notes add a separate connectors section (Beta) to the agent settings page. This area still changes, so check the page again before you build.

![Screenshot of the Databricks documentation page section "How MCP connectors work in a Genie Agent". A teal box marks the sentence "Genie Agents support the following Databricks-provided MCP connectors" and the list below it: Google Drive, Gmail, Google Calendar, Microsoft 365, Atlassian, Asana, Glean, Slack and GitHub.](https://everyinfra.com/articles/databricks-genie-agent-public-social-review-data/img-docs-genie-agents-mcp.webp)

The Genie Agents docs list nine built-in connectors and do not mention custom MCP. Screenshot taken on Nov 14, 2026. [Databricks Docs, Connect a Genie Agent to MCP tools and sources](https://docs.databricks.com/aws/en/genie-agents/external-tools)

| Route | Direction | Who adds it | Can outside data come in? | Stage |
| --- | --- | --- | --- | --- |
| Genie One MCP (`system.ai.genie_one_mcp`) | Outside agent calls Genie | User or service principal with `EXECUTE` | No; it only sends answers out | Generally available |
| Genie One + custom MCP service | Genie One calls an outside server | A user with `CREATE SERVICE` registers it; users add it from Browse connectors | Yes, live | Documented |
| Genie Agents + MCP connectors | Genie Agent calls built-in connectors | The agent author, in Sources | The docs list nine built-in connectors and do not mention custom MCP | Beta |
| `mcp` knowledge source in `ai_enrich` | A SQL function calls an outside MCP search tool per row | The SQL author | Yes, one row at a time | Documented; needs Databricks Runtime 18.2+ |

The [`ai_enrich` function](https://docs.databricks.com/aws/en/sql/language-manual/functions/ai_enrich) can use a registered external MCP as a knowledge source and generate new columns per row. The docs require a shared credential, such as a provider API key used as a bearer token, because the function cannot show a sign-in prompt. The docs also warn that the query built from each row goes to the outside provider. This route fits "add one outside field to each row of a brand table." It does not fit a job that pulls new reviews over time.

## Why public reviews belong next to your sales tables

Your sales, returns and ticket tables record what your own customers did. Trustpilot, Google Play and Reddit record what customers say in public. Some of those people never contact your support team. When both sides live in the same Unity Catalog, Genie can answer questions across them. Here is an example: "did the 1-star reviews that mention steak last week also appear in refund tickets that week?"

The [Genie Agents concepts page](https://docs.databricks.com/aws/en/genie-agents/concepts) says that a Genie Agent works on tables, views, metric views and materialized views in Unity Catalog. Its SQL is read-only. The [setup page](https://docs.databricks.com/aws/en/genie-agents/set-up) sets a limit of 50 tables per agent. The [best practices page](https://docs.databricks.com/aws/en/genie-agents/best-practices) suggests five or fewer. Public reviews take one to three of those slots.

We also watched the top YouTube walkthroughs for this keyword. One creator says "you can connect up to 30 tables here" while building a Genie Agent. The November docs say 50, so we follow the docs.

An official Databricks demo shows that Unity Catalog stores an external MCP server as an HTTP connection. You can also install one from Marketplace. Step 1 of route 1 below creates this kind of HTTP connection.

![Illustration. On the left, review cards with star ratings and chat bubbles float in and split into two routes toward a glass data warehouse on the right. The upper route is a thin glowing pipe to a small desk, where a four-point star reads the cards one by one. The lower route is a conveyor belt that carries stacks of cards past a wall clock into round storage drums inside the warehouse.](https://everyinfra.com/articles/databricks-genie-agent-public-social-review-data/img-two-routes.webp)

Two routes: ask live in chat through MCP (top), or land reviews in a table on a schedule and let Genie query it (bottom).

## Live test: three sources and three rounds for HelloFresh

The table design and the schedule both depend on real data. So before we wrote any configuration, we ran three rounds of calls for HelloFresh. Each round called three capabilities. `trustpilot/reviews` read `hellofresh.com`, newest first, 50 rows. `google_play/reviews` read the Android app `com.hellofresh.androidapp`, newest first, 100 rows. `reddit/subreddit_posts` read r/hellofresh, newest first, 50 posts.

Each round also ran one site-wide `reddit/search` for the keyword "HelloFresh". The rounds ran at 13:08, 13:28 and 13:48 Singapore time on November 14. The last call was at 13:49, about 41 minutes after the first.

Round T1 is the full pull. Rounds T2 and T3 count only IDs that no earlier round returned. We dedupe on platform plus ID, the same rule as `dedupe_key` in the Delta table.

| Round (Singapore time) | Capability | Returned this time | New IDs | Known IDs with changes | `charged_usd` |
| --- | --- | --- | --- | --- | --- |
| T1 13:08 | `trustpilot/reviews` | 50 | — | — | $0.001389 |
| T1 13:10 | `google_play/reviews` | 100 | — | — | $0.001389 |
| T1 13:11 | `reddit/subreddit_posts` | 50 | — | — | $0.000556 |
| T1 13:08 | `reddit/search` | 2 | — | — | $0.000792 |
| T2 13:28 | `trustpilot/reviews` | 50 | 0 | 0 | $0.001389 |
| T2 13:28 | `google_play/reviews` | 100 | 0 | 0 | $0.001389 |
| T2 13:28 | `reddit/subreddit_posts` | 50 | 0 | 0 | $0.000556 |
| T2 13:28 | `reddit/search` | 2 | 0 | 1 | $0.000792 |
| T3 13:48 | `trustpilot/reviews` | 50 | 0 | 0 | $0.001389 |
| T3 13:48 | `google_play/reviews` | 100 | 0 | 0 | $0.001389 |
| T3 13:49 | `reddit/subreddit_posts` | 50 | 0 | 0 | $0.000556 |
| T3 13:48 | `reddit/search` | 1 | 0 | 1 | $0.000792 |

![Grouped bar chart. New IDs in each round compared with all earlier rounds. T1 at 13:08: the three sources returned 200 rows together, all new, in teal. T2 at 13:28 and T3 at 13:48: 200 rows each, 0 new IDs. Data from EveryInfra live calls, Nov 14, 2026, Singapore time, deduped on platform plus id.](https://everyinfra.com/articles/databricks-genie-agent-public-social-review-data/fig-04-new-ids-per-round-bar.en.light.svg)

At 13:28 and 13:48, Trustpilot, Google Play and r/hellofresh returned 0 new IDs. They returned the same rows as T1, and no known row in these three sources changed. This matches the rates above. Trustpilot gets about 7.4 reviews a day, so a new review arrives about every three hours. The newest Trustpilot review in T1 was posted at 02:19 UTC, three and a half hours before T3.

Only `reddit/search` changed. In T2, one post had a new like count. In T3 the call returned 1 row this time, and that post had new like and comment counts. In public data, engagement counts change most often. So the `MERGE` must update `like_count` and `comment_count`. But these columns are not a reason to pull more often.

Engagement levels also differ a lot by source. Only 9 of the 100 Google Play reviews had a `thumbs_up` value above 0, and the highest was 5. The 50 r/hellofresh posts had a median like count of 7.5, and the top post had 78. So Google Play likes do not tell reviews apart. If users ask "which review got the most support," tell Genie in the column comment to sort by likes only for Reddit posts.

The median response time was 12.2 seconds (n=12: the 12 calls in the table above, four capabilities). In Genie One chat, the user waits more than ten seconds before Genie has the data and starts to answer.

Response size matters for live chat calls too. In T1, 50 `trustpilot/reviews` rows were 71,697 bytes, about 1.4 KB per row. 100 `google_play/reviews` rows were 71,202 bytes, about 0.7 KB per row. 50 `reddit/subreddit_posts` rows were 38,531 bytes, about 0.8 KB per row. The MCP call at 13:29 asked only for 10 one- and two-star Trustpilot reviews, and the response was 16,447 bytes.

| Call | Rows returned | Bytes | Bytes per row (about) |
| --- | --- | --- | --- |
| `trustpilot/reviews`, T1 | 50 | 71,697 | 1,434 |
| `google_play/reviews`, T1 | 100 | 71,202 | 712 |
| `reddit/subreddit_posts`, T1 | 50 | 38,531 | 771 |
| `trustpilot/reviews` with `stars`, MCP at 13:29 | 10 | 16,447 | 1,645 |

A rough rule for English text is 4 bytes per token. By that estimate, 50 Trustpilot reviews take more than ten thousand tokens of context in one call. For live questions in chat, keep `limit` small and filter with `stars` first. For full history and trends, use the table route.

## What each source looks like

All numbers below come from the three rounds after dedupe on ID. The sample is one brand on one day. It does not describe an industry.

Of the 50 Trustpilot reviews, 43 had `verification_level` set to `invited` and `source` set to `InvitationLinkApi`. The company asked these customers to write a review through an invitation link. The other 7 had `not-verified` and `Organic`. These customers came to Trustpilot on their own. The [Trustpilot help article on review labels](https://help.trustpilot.com/s/article/About-Trustpilots-review-labels?language=en_US) labels reviews from the Invitation Link API as "Invited" and organic reviews as "Unprompted review". The public page shows the two kinds with different labels.

In this sample, the star ratings of the two groups are far apart. Of the 7 organic reviews, 6 had 1 or 2 stars, which is 85.7%. Of the 43 invited reviews, only 8 had 1 or 2 stars, which is 18.6%. At 13:29 we used MCP to get the 10 newest reviews with 1 or 2 stars. Five were organic and five were invited, although organic reviews were only 7 of the 50 newest. If a Genie Agent averages ratings without this split, invited reviews hide the organic complaints.

On a 1 to 5 scale, the 43 invited reviews average 3.70 stars and the 7 organic reviews average 1.57. All 50 together average 3.40. Only 1 organic review had 4 stars, and none had 5.

![Horizontal bar chart. Share of 1 to 2 star reviews. Trustpilot invited: 18.6% (8 of 43). Trustpilot organic: 85.7% (6 of 7), highlighted in teal. Google Play: 20.0% (20 of 100). Data from EveryInfra live calls, Nov 14, 2026, Singapore time, 3 rounds deduped by id.](https://everyinfra.com/articles/databricks-genie-agent-public-social-review-data/fig-05-low-star-share-bar.en.light.svg)

![Stacked percentage bar chart. Star distribution in three samples, 1 and 2 stars in teal. Trustpilot invited, 43 rows: 1 star 9%, 2 stars 9%, 3 stars 21%, 4 stars 23%, 5 stars 37%. Trustpilot organic, 7 rows: 1 star 71%, 2 stars 14%, 4 stars 14%, no 3 or 5 stars. Google Play, 100 rows: 17%, 3%, 9%, 17%, 54%. Data from EveryInfra live calls, Nov 14, 2026, Singapore time, 3 rounds deduped by id.](https://everyinfra.com/articles/databricks-genie-agent-public-social-review-data/fig-08-star-mix-bar.en.light.svg)

Reply speed also differs. HelloFresh replied to 42 of the 50 Trustpilot reviews. The median time from review to reply was 22.1 hours. Split by type, 38 of 43 invited reviews got a reply, with a median of 22.3 hours. 4 of 7 organic reviews got a reply, with a median of 17.3 hours. Four values show only the order of size.

On Google Play, the developer replied to 23 of 100 reviews, with a median of 0.8 hours. Of those 23 replies, 11 went to 1 or 2 star reviews. The developer replied to 10 of the 17 one-star reviews but only 4 of the 54 five-star reviews.

So Google Play gets fewer replies, but they come fast. Trustpilot gets a reply on almost every review, but a day later. This is why the `MERGE` must update known rows. Most Trustpilot replies appear about one day after the review is already in the table.

![Horizontal bar chart. Median hours from review to company reply. Trustpilot invited: 22.3 hours, 38 of 43 replied. Trustpilot organic: 17.3 hours, 4 of 7. Google Play: 0.8 hours, 23 of 100, highlighted in teal. Data from EveryInfra live calls, Nov 14, 2026, Singapore time, 3 rounds deduped by id.](https://everyinfra.com/articles/databricks-genie-agent-public-social-review-data/fig-07-reply-hours-bar.en.light.svg)

The reply rate by star shows opposite habits on the two platforms. On Trustpilot, 26 of 27 reviews with 4 or 5 stars got a reply, but only 10 of 14 reviews with 1 or 2 stars. On Google Play, 11 of 20 reviews with 1 or 2 stars got a reply (55%). Only 8 of 71 reviews with 4 or 5 stars did (11%). The total reply rate makes Trustpilot look much better, 84% against 23%. For the question "does someone answer the complaints," the gap is much smaller. Add "reply rate for negative reviews" as its own benchmark question in the Genie Agent.

| Platform | 1–2 stars: replied / total | 4–5 stars: replied / total | All: replied / total |
| --- | --- | --- | --- |
| Trustpilot | 10 / 14 | 26 / 27 | 42 / 50 |
| Google Play | 11 / 20 | 8 / 71 | 23 / 100 |

By `score`, the 100 Google Play reviews had 54 five-star, 17 four-star, 9 three-star, 3 two-star and 17 one-star reviews. One- and two-star reviews were 20% in total. 85 of the 100 reviews came from four app versions, 26.42 to 26.45. 15 of the 20 negative reviews came from the same four versions.

| `app_version` | Rows in this sample | 1–2 stars | Negative share |
| --- | --- | --- | --- |
| 26.42 | 28 | 4 | 14% |
| 26.44 | 25 | 6 | 24% |
| 26.45 | 17 | 3 | 18% |
| 26.43 | 15 | 2 | 13% |
| Other 15 rows | 15 | 5 | — |

Each version has only 15 to 28 rows. These differences do not show that one version is worse. To see a version trend, collect a few weeks of data in the table first. This is also why `app_version` is a real column and not part of `extra`. When Genie groups by version, it needs a normal column with a comment.

Negative reviews are also longer. We measured the median text length in characters. The 14 Trustpilot reviews with 1 or 2 stars have 206.5 characters, and the 27 with 4 or 5 stars have 102. On Google Play, the 20 negative reviews have 162.5 characters, and the 71 with 4 or 5 stars have 63. Negative text is about two to two and a half times longer.

The MCP call at 13:29 shows the same effect. Its 10 negative reviews were about 1.6 KB per row, more than the 1.4 KB per row in the mixed T1 batch. When you ask for negative reviews in live chat, set `limit` even lower.

The 50 r/hellofresh posts have no stars. The signal is in `flair` and `comment_count`. 22 posts had no flair. 13 had "United States", 8 had "Question" and 4 had "Picture". Reddit posts answer "what are customers asking about". Examples are how to cancel, delivery areas or how to cook a dish. Do not average them with review stars.

Discussion is concentrated. The median post had 4 comments. The top 3 posts had 79, 43 and 27 comments, 149 in total, which is 32.9% of all 453 comments. So a daily brief that lists the most-discussed posts covers about a third of the talk.

| Source | Sample | 1–2 stars | With a reply | Median reply time | Good for |
| --- | --- | --- | --- | --- | --- |
| `trustpilot/reviews` (invited) | 43 rows | 8 | 38 | 22.3 hours | Overall satisfaction of buyers |
| `trustpilot/reviews` (organic) | 7 rows | 6 | 4 | 17.3 hours (4 values) | What complainers say on their own |
| `google_play/reviews` | 100 rows | 20 | 23 | 0.8 hours | App version and feature issues |
| `reddit/subreddit_posts` | 50 posts | No stars | None | None | What customers ask and discuss |

## Table design: one Delta table for three sources

The three sources use different field names. Star rating is `rating` on Trustpilot and `score` on Google Play. Likes are `thumbs_up` on Google Play and `like_count` on the other two. With one table per source, a Genie Agent must write three `UNION` blocks to answer "how many 1–2 star items did we get across channels last week." That doubles the chance of a wrong query. We use one wide table instead. Shared fields become columns, and fields that only one source has go into a `VARIANT` column.

The three right columns show the field name in the catalog `response_fields`. A dash means that the source does not have that field. A script compared every source field in this map with the live catalog `response_fields` on November 14. The difference was empty.

| Delta column | `trustpilot/reviews` | `google_play/reviews` | `reddit/subreddit_posts` |
| --- | --- | --- | --- |
| `source_id` | `id` | `id` | `id` |
| `url`, `title`, `text` | same name | same name | same name |
| `rating` | `rating` (1–5) | `score` (1–5) | — |
| `like_count` | `like_count` | `thumbs_up` | `like_count` |
| `comment_count` | — | — | `comment_count` |
| `reply_text`, `reply_at` | same name (company reply) | same name (developer reply) | — |
| `posted_at` | `posted_at` | `posted_at` | `posted_at` |
| `updated_at`, `experience_at` | same name | — | — |
| `language` | `language` | `language` | — |
| `country`, `verification_level`, `review_source` | `country`, `verification_level`, `source` | — | — |
| `app_version` | — | `app_version` | — |
| `community`, `flair` | — | — | `community`, `flair` |
| `author_hash` | hash of `author_name` | hash of `author_name` | hash of `author_username` |

We store only a hash of the author name. Many colleagues will read Genie answers. Reviewer names add nothing to the analysis, and they add a privacy task. A hash still lets you count posts per person. We drop the avatar URL fields (`author_image`, `author_avatar_url`). We add three columns of our own: `dedupe_key` (source plus original id, for example `trustpilot:6af7a918…`), `snapshot_ts` (time of the API call) and `ingested_at` (time of the table write).

```text
-- Configuration example: target table in Unity Catalog (not executed on Databricks)
CREATE TABLE IF NOT EXISTS main.voice.public_brand_reviews (
  dedupe_key         STRING NOT NULL COMMENT 'source:original_id, e.g. trustpilot:6af7...; key for dedupe and MERGE',
  source             STRING NOT NULL COMMENT 'EveryInfra capability: trustpilot/reviews, google_play/reviews, reddit/subreddit_posts',
  brand              STRING NOT NULL COMMENT 'brand slug, e.g. hellofresh',
  source_id          STRING NOT NULL,
  url STRING, title STRING, text STRING,
  rating             INT    COMMENT '1-5 stars; NULL for Reddit',
  like_count         INT, comment_count INT,
  reply_text         STRING COMMENT 'company or developer reply; NULL = no reply yet',
  reply_at           TIMESTAMP,
  posted_at          TIMESTAMP NOT NULL,
  updated_at         TIMESTAMP, experience_at TIMESTAMP,
  language STRING, country STRING,
  verification_level STRING COMMENT 'Trustpilot: invited = invited by the company, not-verified = organic',
  review_source STRING, app_version STRING, community STRING, flair STRING,
  author_hash        STRING COMMENT 'sha256(author name); raw name is not stored',
  extra              VARIANT COMMENT 'other source fields',
  snapshot_ts        TIMESTAMP NOT NULL,
  ingested_at        TIMESTAMP NOT NULL
) CLUSTER BY (brand, source, posted_at)
COMMENT 'Public reviews and posts, deduped on dedupe_key, daily incremental MERGE';
```

`CLUSTER BY` uses Delta [liquid clustering](https://docs.databricks.com/aws/en/delta/clustering). Most queries that Genie writes filter by brand, source and time, so clustering on those three columns reduces the data that each query reads. Write clear column comments. The [Genie Agents best practices page](https://docs.databricks.com/aws/en/genie-agents/best-practices) puts table and column descriptions in Unity Catalog first on its list of accuracy factors. The `verification_level` column needs the clearest comment of all, for reasons that the section "What each source looks like" shows with numbers.

## Daily increments: a watermark plus a look-back window

None of the three sources accepts "give me reviews after this timestamp." `trustpilot/reviews` has a `date` parameter, but it only accepts relative windows such as `last7days` or `last30days`. `google_play/reviews` and `reddit/subreddit_posts` sort by newest and return the latest N rows. So you build the increment yourself. Keep one watermark per source: the newest `posted_at` that you saw last time. On each run, pull a newest-first batch, dedupe on `dedupe_key`, and `MERGE` into the table.

How many rows per call is enough depends on how fast each source moves. In round T1, the newest 50 Trustpilot reviews reached back 6.77 days. The newest 100 Google Play reviews reached back 27.59 days. The newest 50 r/hellofresh posts reached back 9.17 days. At those rates, a daily job sees about 7.4 Trustpilot reviews, 3.6 Google Play reviews and 5.5 subreddit posts per day.

A limit of 50 per call gives several times the margin. There is one simple check for a gap. If the oldest `posted_at` in the batch is still newer than the watermark, the batch did not reach back far enough. In that case, fetch the next page (Google Play returns a `next_page_token`) or raise `limit`.

![Horizontal bar chart. Same brand, HelloFresh, newest first: how many days the newest N rows from one call reach back. Trustpilot reviews, 50 rows: 6.8 days, highlighted in teal. r/hellofresh posts, 50 rows: 9.2 days. Google Play reviews, 100 rows: 27.6 days. Data from EveryInfra live calls on Nov 14, 2026, 13:08 to 13:11 Singapore time.](https://everyinfra.com/articles/databricks-genie-agent-public-social-review-data/fig-03-coverage-days-bar.en.light.svg)

Do not make the watermark too strict. A Trustpilot review has two timestamps, `posted_at` and `updated_at`. The first review in T1 has `posted_at` 02:19:36 UTC and `updated_at` 02:49:31 UTC. The reviewer edited it half an hour after posting.

Company replies also arrive later. If you insert only ids that are newer than the watermark, you lose later replies and edits on older reviews.

So the `MERGE` has two branches. New `dedupe_key` values are inserted. Known keys are updated only when the reply, text or like count changed.

The [Delta MERGE docs](https://docs.databricks.com/aws/en/delta/merge) add two warnings. First, dedupe the source batch itself, or duplicate rows inside one batch are all inserted. Second, a time condition narrows the search for duplicates. Where you put that condition matters, as the note after the code explains.

```text
-- Configuration example: daily incremental write (the staging table comes from the job below)
MERGE INTO main.voice.public_brand_reviews AS t
USING (
  SELECT * FROM main.voice.public_brand_reviews_staging
  WHERE posted_at > current_timestamp() - INTERVAL 60 DAYS   -- look-back on the source side
  QUALIFY ROW_NUMBER() OVER (PARTITION BY dedupe_key ORDER BY snapshot_ts DESC) = 1
) AS s
ON t.dedupe_key = s.dedupe_key                                -- match on the dedupe key only
WHEN MATCHED AND (t.reply_text IS DISTINCT FROM s.reply_text
               OR t.text IS DISTINCT FROM s.text
               OR t.like_count IS DISTINCT FROM s.like_count) THEN
  UPDATE SET t.reply_text = s.reply_text, t.reply_at = s.reply_at, t.text = s.text,
             t.like_count = s.like_count, t.updated_at = s.updated_at, t.snapshot_ts = s.snapshot_ts
WHEN NOT MATCHED THEN INSERT *;
```

The 60-day look-back comes from the Google Play numbers: the newest 100 rows covered 27.59 days, and we doubled that for margin.

Put this time condition in the `USING` subquery, on the staging data. Do not put it in `ON`. With the condition in `ON`, a review older than 60 days in staging does not match its row in the table. The `MERGE` treats it as NOT MATCHED and inserts it again every day, so the table gets duplicate rows. A low-volume source can return such old reviews on its newest page. With the condition on the source side, old reviews skip this merge, and their existing rows stay as they are. We do not handle deleted reviews here. With one newest-first page per run, "not on this page" does not mean "deleted."

## Several jobs writing one table

One job for one brand is simple. Soon marketing adds competitors and support adds its own product lines. Then five or six jobs write to `public_brand_reviews` in the same hour.

The [Databricks docs on isolation levels and write conflicts](https://docs.databricks.com/aws/en/optimizations/isolation-level) state the risk. When several jobs or users write the same table at the same time, some writes can fail with a conflict exception. We did not test this on Databricks either. The setup below is a configuration example.

| Rule from the docs | What we do in this table |
| --- | --- |
| Row-level concurrency needs Databricks Runtime 14.3 LTS or later | Run jobs on 14.3 LTS or later |
| Row-level concurrency needs a table without partitions | Use liquid clustering, not partitions |
| Row-level concurrency needs deletion vectors | Turn them on once, when no job runs |
| Explicit filters in the `MERGE` condition keep file sets apart | Add `t.brand = '<brand>'` to the `ON` clause |
| Only the operation that reads the changed data fails | Put the retry on the `MERGE` step |
| Tables with identity columns do not support concurrent transactions | Use the string `dedupe_key`, not an identity column |
| Metadata changes can fail all concurrent writes | Keep new source fields in `extra` (`VARIANT`) |

The [row-level concurrency page](https://docs.databricks.com/aws/en/optimizations/isolation/row-level-concurrency) lists three conditions: Databricks Runtime 14.3 LTS or later, no partitions, and deletion vectors on. When all three hold, two parallel `MERGE` runs that change different rows in the same file resolve without a conflict. Our table already has no partitions. Turn on deletion vectors with one `ALTER TABLE`. That statement is itself a metadata change. So run it once at setup, when no job is running.

```text
-- Configuration example: run once after CREATE TABLE, outside job hours
ALTER TABLE main.voice.public_brand_reviews SET TBLPROPERTIES ('delta.enableDeletionVectors' = true);
-- In each brand's MERGE, add the brand to the match condition:
--   ON t.brand = 'hellofresh' AND t.dedupe_key = s.dedupe_key
-- Keep the 60-day filter in the USING subquery on the staging table, not in ON.
```

Give each brand its own staging table, such as `public_brand_reviews_staging_hellofresh`. Then one job's `INSERT OVERWRITE` cannot wipe rows that another job has not merged yet. The API step already has its own retries and idempotency key, so a re-run is not charged twice. If the `MERGE` fails, wait some seconds and run the same statement again. The staging data is still there. Readers are safe too. The docs say that a reader sees a consistent snapshot from the start of its query. A Genie Agent query that runs during a job does not see half-written data.

## Route 1: ask live in Genie One through the remote MCP (configuration example)

This route fits one-off questions. A product manager asks Genie One, "What are the latest 10 one- and two-star HelloFresh reviews on Trustpilot about?" Genie calls an EveryInfra tool at that moment and gets the data. Nothing is written to a table. We did not run these steps in a Databricks workspace. They follow the [external MCP servers docs](https://docs.databricks.com/aws/en/ai-gateway/register-mcp-service), last updated on October 27, 2026.

Step 1 is to store the key in a Unity Catalog HTTP connection. The [HTTP connection docs](https://docs.databricks.com/aws/en/query-federation/http) show SQL that reads the bearer token from a secret scope. The key then never appears in anyone's code. The docs also say that the token is sent only to the host name that you set on the connection.

```text
-- Configuration example: put the key in the secret scope "everyinfra" first
CREATE CONNECTION everyinfra_mcp TYPE HTTP
OPTIONS (
  host 'https://api.everyinfra.com',
  port '443',
  base_path '/mcp',
  bearer_token secret('everyinfra', 'api_key')
);
```

Step 2 is to register the server. In Unity Gateway, open MCPs and click "+ MCP." Choose "Connect an existing MCP server." Pick a catalog and schema, for example `main.voice`. Name the service `everyinfra`. You cannot change the name later. Select the `everyinfra_mcp` connection and click "Create & load tools."

The EveryInfra MCP server lists 12 tools. We checked this with `tools/list` at 13:11 Singapore time on November 14. For this job you only need three read tools: `everyinfra_list_capabilities`, `everyinfra_call_api` and `everyinfra_get_job`. Turn off the others, such as tickets, top-up links and captcha tools. Fewer tools use less model context and remove one class of wrong calls.

The full service name is now `main.voice.everyinfra`. Its URL is `https://<workspace-hostname>/ai-gateway/mcp-services/main.voice.everyinfra`. The docs suggest a first test in AI Playground. Pick a model with tools, add the external MCP, and ask it to call one read tool.

Step 3 is access. The [Unity Gateway MCP governance docs](https://docs.databricks.com/aws/en/ai-gateway/govern-mcp-service) show how to grant `EXECUTE` to a group. The [Genie One external applications docs](https://docs.databricks.com/aws/en/genie-one/external-sources) describe how a user adds the service. In the chat box, open the plus menu, then "Connectors", then "Browse connectors". Before each tool call, the gateway checks that the caller has `EXECUTE`. It also writes usage and audit records to system tables.

The key on the connection is a shared credential. Every user with `EXECUTE` spends from the same EveryInfra account. So decide the grant and the budget together.

Here is the tool call that Genie sends. We sent this exact request at 13:29 Singapore time on November 14 to `https://api.everyinfra.com/mcp`. The arguments match the question in the chat.

```text
{"jsonrpc": "2.0", "id": 3, "method": "tools/call",
 "params": {"name": "everyinfra_call_api",
            "arguments": {"platform": "trustpilot", "action": "reviews",
                          "params": {"company": "hellofresh.com", "stars": ["1", "2"], "limit": 10}}}}
```

The response `results` held 10 reviews with 1 or 2 stars: 8 with 1 star and 2 with 2 stars. `charged_usd` was $0.001389, the same price as a REST call. The call is charged once, not per row. Five of the 10 rows had `verification_level` set to `not-verified` and five had `invited`. All 10 also appeared in the 50 newest rows from the 13:28 round.

For a quick question such as "recent negative reviews," filter with `stars` first and ask for 10 rows. The model then reads much less text and gives a more focused answer. The image below shows the first two rows of this response, with author names hidden.

![Screenshot of a real EveryInfra response: a dark code card with the first two rows of the trustpilot/reviews JSON. Fields shown are id, title, text (cut short), rating, verification_level, posted_at and reply_at. Author names are hidden. Teal boxes mark the rating and verification_level fields.](https://everyinfra.com/articles/databricks-genie-agent-public-social-review-data/img-mcp-response.webp)

Real response from trustpilot/reviews through MCP. Two rows shown, long text cut, author names hidden. [EveryInfra API response screenshot, Nov 14, 2026](https://api.everyinfra.com/api/v1/social/catalog)

## Route 2: a scheduled job writes to Delta through REST, then a Genie Agent queries it (configuration example)

Some questions need history, such as "last month" or "compared with the same week last year." A Genie Agent, unlike Genie One chat, also needs a table. This route uses one Lakeflow job that runs once a day. It calls the EveryInfra REST API, writes a staging table, and then runs the `MERGE` from "Daily increments".

The request does not have to touch the key. The HTTP connection docs describe a proxy address: `https://<workspace-hostname>/api/2.0/unity-catalog/connections/<connection-name>/proxy/<sub-path>`. Databricks adds the stored credential and forwards the request. Create a second connection, `everyinfra_api`, with `base_path` set to `/api/v1`. The job then posts to `.../connections/everyinfra_api/proxy/social`.

The docs do not say whether the proxy forwards custom headers unchanged. If the `Idempotency-Key` header is dropped, fall back to `dbutils.secrets.get` and call `https://api.everyinfra.com/api/v1/social` directly. The [secrets docs](https://docs.databricks.com/aws/en/security/secrets/) confirm that jobs can read workspace secret scopes with `dbutils.secrets`.

```text
# Configuration example: one Python task in a Lakeflow job.
# Request parameters match our local live test on Nov 14; not run on Databricks.
import hashlib, json, time, datetime, requests
from pyspark.sql import Row

KEY = dbutils.secrets.get("everyinfra", "api_key")
URL = "https://api.everyinfra.com/api/v1/social"
RUN_DAY = datetime.date.today().isoformat()
JOBS = [
    ("trustpilot", "reviews", {"company": "hellofresh.com", "sort": "newest", "limit": 50}),
    ("google_play", "reviews", {"app_id": "com.hellofresh.androidapp", "sort": "newest", "limit": 100}),
    ("reddit", "subreddit_posts", {"subreddit": "hellofresh", "sort": "newest", "limit": 50}),
]

def call(platform, action, params):
    # Same key for the same capability on the same day: a re-run is not charged twice
    idem = f"hellofresh:{platform}:{action}:{RUN_DAY}"
    for attempt in range(4):
        r = requests.post(URL, timeout=120, json={"platform": platform, "action": action, "params": params},
                          headers={"Authorization": f"Bearer {KEY}", "Idempotency-Key": idem})
        if r.status_code == 429:
            time.sleep(int(r.json()["error"].get("retry_after", 60))); continue
        if r.status_code in (502, 503, 504):
            time.sleep(30 * (attempt + 1)); continue   # failed calls are not charged; retry later
        r.raise_for_status()
        return r.json()
    raise RuntimeError(f"{platform}/{action} failed after 4 tries")

rows, snap = [], datetime.datetime.utcnow()
for platform, action, params in JOBS:
    body = call(platform, action, params)
    for x in body["results"]:
        rows.append(Row(
            dedupe_key=f"{platform}:{x['id']}", source=f"{platform}/{action}", brand="hellofresh",
            source_id=x["id"], url=x.get("url"), title=x.get("title"), text=x.get("text"),
            rating=x.get("rating", x.get("score")), like_count=x.get("like_count", x.get("thumbs_up")),
            comment_count=x.get("comment_count"), reply_text=x.get("reply_text"), reply_at=x.get("reply_at"),
            posted_at=x["posted_at"], updated_at=x.get("updated_at"), experience_at=x.get("experience_at"),
            language=x.get("language"), country=x.get("country"), verification_level=x.get("verification_level"),
            review_source=x.get("source"), app_version=x.get("app_version"), community=x.get("community"),
            flair=x.get("flair"),
            author_hash=hashlib.sha256((x.get("author_name") or x.get("author_username") or "").encode()).hexdigest(),
            extra=json.dumps({k: v for k, v in x.items() if k in ("author_review_count", "is_verified", "domain", "external_link")}),
            snapshot_ts=snap.isoformat(), ingested_at=datetime.datetime.utcnow().isoformat()))

spark.createDataFrame(rows).createOrReplaceTempView("batch")
spark.sql("""INSERT OVERWRITE main.voice.public_brand_reviews_staging
             SELECT dedupe_key, source, brand, source_id, url, title, text, CAST(rating AS INT),
                    CAST(like_count AS INT), CAST(comment_count AS INT), reply_text, CAST(reply_at AS TIMESTAMP),
                    CAST(posted_at AS TIMESTAMP), CAST(updated_at AS TIMESTAMP), CAST(experience_at AS TIMESTAMP),
                    language, country, verification_level, review_source, app_version, community, flair,
                    author_hash, parse_json(extra), CAST(snapshot_ts AS TIMESTAMP), CAST(ingested_at AS TIMESTAMP)
             FROM batch""")
# Then run the MERGE from the "Daily increments" section
```

We explain the idempotency key in a separate post: [how to use Idempotency-Key so agent retries are not charged twice](/blog/api-idempotency-key-ai-agent-retry). Set the schedule under "Schedules & Triggers," as the [scheduled jobs docs](https://docs.databricks.com/aws/en/jobs/scheduled) describe. Advanced mode accepts Quartz cron syntax and a time zone. The docs give one warning about daylight saving time. An hourly job in such a time zone can be skipped or late by an hour or two on the change day. A daily job is not affected.

![Flow diagram. Top route: Genie One chat calls the EveryInfra remote MCP live through the external MCP main.voice.everyinfra registered in Unity Gateway; results stay in the chat and are not stored. Bottom route: a Lakeflow job runs once a day, calls trustpilot/reviews, google_play/reviews and reddit/subreddit_posts through REST, writes a staging table, and merges into the Delta table public_brand_reviews. A Genie Agent queries this table together with sales and ticket tables.](https://everyinfra.com/articles/databricks-genie-agent-public-social-review-data/fig-02-two-routes-flow.en.light.svg)

When the table exists, add `public_brand_reviews` to the Genie Agent next to your own sales and ticket tables. Then write a few instructions. The [Genie Agents concepts page](https://docs.databricks.com/aws/en/genie-agents/concepts) explains the access model. SQL runs on a SQL warehouse with the compute credentials that the author embedded. Data access follows the Unity Catalog permissions of the person who asks. So you can grant the review table to the marketing and support teams only.

We suggest these three lines in the agent instructions:

> 1. "Negative review" means `rating` is 1 or 2. Reddit posts have no rating and do not count as negative reviews. 2. On Trustpilot, `verification_level = 'invited'` means the company invited the review. `'not-verified'` means an organic review. When someone asks what customers say on their own, use only organic reviews. 3. Use `posted_at` for time. "Recent" means the last 7 days unless the question says otherwise.

## What you can ask a Databricks Genie Agent: example SQL

The [Genie Agents best practices page](https://docs.databricks.com/aws/en/genie-agents/best-practices) prefers another method. Define business meaning with SQL expressions and example SQL queries. Keep plain text instructions for cases that SQL cannot express. Example SQL lets Genie match a user question to a verified query and learn from it for similar questions. So after you create the table, add example SQL for the most common questions. The table below lists three that we designed from the HelloFresh data. The ticket table `main.support.tickets` is an assumed structure. Replace it with your own.

| Question | Key filter or method | Check against our test data |
| --- | --- | --- |
| What did organic negative reviews say last week? | `verification_level = 'not-verified'` and `rating <= 2`, by `posted_at` | 8 of the 14 negative reviews were invited, so filter first |
| Do review complaints show up in refund tickets? | Join by week and by a keyword table that the business owns | Approximate match; reviewers and buyers are not linked |
| Which channel do we reply to slowly? | Median of `reply_at` minus `posted_at` per source, plus the reply rate for 1–2 stars | About 22 hours on Trustpilot, under 1 hour on Google Play; negative reply rate 10/14 and 11/20 |

```text
-- Configuration example: example SQL "median reply time per channel, in hours"
SELECT source,
       count(*) AS reviews,
       count(reply_at) AS replied,
       percentile(timestampdiff(MINUTE, posted_at, reply_at) / 60.0, 0.5) AS median_reply_hours,  -- rows without a reply have NULL and are skipped
       count_if(rating <= 2 AND reply_at IS NOT NULL) / count_if(rating <= 2) AS low_star_reply_rate
FROM main.voice.public_brand_reviews
WHERE brand = 'hellofresh' AND rating IS NOT NULL
GROUP BY source;
```

Sometimes the Genie answer is far from the numbers in the right column. Then it probably counted reviews without a reply, or it mixed invited and organic reviews. Add these three questions as benchmark questions.

The first question also needs the right time column. Each Trustpilot review has `experience_at` (the date of the customer's experience) and `posted_at` (when the review went up). In the 50 T1 reviews, the median gap from experience to posting was 12.7 days. 9 reviews came within 3 days, 29 within 3 to 15 days, 4 within 15 to 60 days, and 8 after more than 60 days. The longest gap was 304.8 days.

If "last week" uses `experience_at`, the count for last week keeps going up for two or three more weeks. The same question then gets different answers this week and next week. With `posted_at`, the count is almost final when the week ends. So the example SQL and the agent instructions use `posted_at`. Use `experience_at` only for "on which day did customers have the problem."

![Bar chart. Days from the experience date to the posting date for Trustpilot reviews. Up to 3 days: 9 reviews. 3 to 15 days: 29. 15 to 60 days: 4, in teal. Over 60 days: 8, in teal. Median 12.7 days. Data from EveryInfra live calls, newest 50 HelloFresh reviews, Nov 14, 2026, Singapore time.](https://everyinfra.com/articles/databricks-genie-agent-public-social-review-data/fig-09-experience-lag-bar.en.light.svg)

The best practices page suggests that you add checked questions as benchmarks, test them with different wording and score accuracy. The [Genie Agent monitoring docs](https://docs.databricks.com/aws/en/genie-agents/monitor) add a feedback path. Users can mark an answer for review. People with CAN MANAGE permission then confirm or correct it on the monitoring page.

Review text sometimes contains order numbers, phone numbers or addresses that customers typed themselves. The [row filters and column masks docs](https://docs.databricks.com/aws/en/data-governance/unity-catalog/filters-and-masks/) describe a column mask for that case. For example, only the support group sees the raw `text`. Other people see a version with digit strings removed. A Genie Agent applies the data permissions of the person who asks, so the mask works together with the agent.

## A daily review brief: Genie One scheduled tasks

When the table and the agent exist, the next request is often "send it to me instead of making me ask". The always-on Genie still needs a preview slot, but Genie One has scheduled tasks today. The [Genie One chat docs](https://docs.databricks.com/aws/en/genie-one/chat) say that a scheduled task runs at a set time and posts its result in a chat thread. It also sends you an email with charts and a PDF. Since November 12, a scheduled task can also email other people in your organization. The docs use this case as the example: a daily briefing of all new customer reviews for a store.

You can create a task in chat with plain words, or by hand under Schedules with "Create manually". The manual form asks for a title, instructions, connections, a schedule and a time zone. We prefer the manual form, because fixed instructions keep the brief the same every day. Here is a sample instruction for our table (configuration example):

> Run every day at 9 a.m. Singapore time. Use the table public_brand_reviews with brand = 'hellofresh'. Part 1: new rows per source in the last 24 hours, by posted_at. Part 2: list every organic Trustpilot review (verification_level = 'not-verified') with 1 or 2 stars, one sentence each, and say if it has a reply. Part 3: app versions (app_version) in Google Play reviews with 1 or 2 stars, sorted by count. Part 4: the 3 r/hellofresh posts with the most comments. If a part has no new data, write "nothing new." Do not invent data.

Schedule the brief after the review job, for example job at 8 a.m. and brief at 9 a.m. That leaves time for the `MERGE` and any retries. The brief only reads the table, so more recipients add no API cost.

Each filter in the brief comes from a test result above. Organic reviews get their own part, because in this sample the two groups had very different negative shares (6 of 7 against 8 of 43). Google Play gets an app version part, because 85 of the 100 reviews came from the latest four versions. You can match these versions to your release log. Reddit gets the most-discussed posts, because posts have no stars, and the top 3 posts held a third of all comments.

## Which route for a Databricks Genie Agent

Build the table first. Then open live chat queries to a small group if they need them.

| Point | Route 1: Genie One + custom MCP | Route 2: job into a table + Genie Agent |
| --- | --- | --- |
| Freshness | At the moment you ask | Up to one job cycle late (24 hours for a daily job) |
| History and trends | None; each call gets the latest batch | Yes; the table grows over time |
| Join with sales and ticket tables | The model must combine results in chat | One SQL `JOIN` |
| Who can use it | Genie One users who add it from Browse connectors | All users of the Genie Agent, with table grants |
| Works in a Genie Agent | Custom MCP is not in the documented connector list | Yes; it is a normal Unity Catalog table |
| API cost | One charge per question | A fixed number of calls per day; see the next section |
| Audit | Gateway usage and audit logs per call | Job run history and table version history |
| Stage | Documented | Uses only generally available parts (jobs, Delta, Genie Agents) |

## The cost of one run per day

On the EveryInfra side, we use the catalog `price_usd` and the `charged_usd` field in each response. On November 14 the catalog prices were $0.001389 per call for `trustpilot/reviews`, $0.001389 per call for `google_play/reviews` and $0.000556 per call for `reddit/subreddit_posts`. Each call returns up to `limit` rows and is charged once. In round T1, the three `charged_usd` values matched the catalog. Their sum was $0.003334. That is the API cost of one job run.

| Schedule | Calls per day | API cost per day | API cost per 30 days |
| --- | --- | --- | --- |
| Once a day | 3 | $0.003334 | $0.10 |
| Every 6 hours | 12 | $0.013336 | $0.40 |
| Every hour | 72 | $0.080016 | $2.40 |

The math is $0.001389 + $0.001389 + $0.000556 = $0.003334, times runs per day, times 30 days.

An hourly run makes no sense for this brand. Trustpilot gets about 7.4 new reviews a day. Most hourly runs would only return IDs that you already have. You pay, but you get no new data. Rounds T2 and T3 in the test section show the same thing. Pulls 20 and 40 minutes after T1 returned 0 new IDs from all three sources.

![Bar chart. Same three capabilities: more runs per day means a higher 30-day API cost. Once a day: $0.10, highlighted in teal. Every 6 hours: $0.40. Every hour: $2.40. One run is one call to each of the three capabilities, measured at $0.003334. Data from EveryInfra charged_usd on live calls, Nov 14, 2026, Singapore time.](https://everyinfra.com/articles/databricks-genie-agent-public-social-review-data/fig-06-monthly-cost-bar.en.light.svg)

The Databricks side has three separate costs. The first is Genie itself. The [Genie docs](https://docs.databricks.com/aws/en/genie) say that Genie One and Genie Agents are free for users until January 31, 2027. Service principals are not part of that offer and pay standard rates.

In route 2, a service principal runs the job. But the job only calls EveryInfra and writes a table. It does not call Genie, so it creates no Genie charge. When users ask the Genie Agent questions, that is their own usage.

A note on the [Genie pricing page](https://www.databricks.com/product/pricing/genie) says that the free usage covers only the Genie language model. Queries that Genie writes run on a SQL warehouse, and the warehouse is billed. The page gives one conversion: "150 DBUs = $10.50 in US East." The [Azure Databricks cost monitoring docs](https://learn.microsoft.com/en-us/azure/databricks/genie/monitor-cost) give SQL to track free usage through the `GENIE_FREE_USAGE` SKU.

The second cost is job compute. It depends on whether you use serverless compute or your own cluster, so we do not estimate it. The third is storage. One brand adds a few thousand rows a year, so you can ignore it.

| Cost item | Who pays | What we know on Nov 14 |
| --- | --- | --- |
| EveryInfra API calls | Your EveryInfra account | $0.003334 per daily run, measured |
| Genie questions by users | Free until Jan 31, 2027 | Covers only the Genie language model |
| SQL warehouse for Genie queries | Your Databricks account | Billed; 150 DBUs = $10.50 in US East (pricing page example) |
| Job compute | Your Databricks account | Depends on serverless or cluster; not estimated |
| Storage | Your cloud account | A few thousand rows a year per brand |

## Limits and things to watch

First, the [Genie Agents MCP docs](https://docs.databricks.com/aws/en/genie-agents/external-tools) say that the Agent mode API can use read tools only. Users also cannot complete connector sign-in through the API. If your own app asks a Genie Agent questions through the API, the connector must already be authorized in the UI.

Second, when you add a custom MCP service to Genie One with per-user OAuth, each user must sign in once. A shared bearer token skips that step. But then everyone spends from the same account.

The data side has limits too. In round T1, `reddit/search` with the keyword "HelloFresh" and newest-first sorting returned 2 rows this time. At the same moment, `reddit/subreddit_posts` on r/hellofresh returned 50 rows. Use the search to find mentions in other communities. Use the community feed for the daily increment.

All 50 Trustpilot rows for `hellofresh.com` in T1 had `country` set to US. To see other countries, set `company` to the domain of that country's site and query each one on its own.

Last, platform rules. Many teams use public reviews for internal analysis and product work. But reposting review text, training models on reviews, or publishing reviewer details is a different matter. Each platform has its own terms, for example the [Reddit Data API Terms](https://redditinc.com/policies/data-api-terms) and the [Trustpilot guidelines for reviewers](https://legal.trustpilot.com/for-reviewers/guidelines-for-reviewers).

Ask your legal team about these questions. This article is not legal advice. The table stores only a hash of the author name to reduce this risk.

## How this differs from our earlier posts

We have two related posts. [Airbyte MCP with social data](/blog/airbyte-mcp-social-data-agent) shows that the Airbyte MCP can query orders and returns in your warehouse, but not public reviews. Its focus is matching reviews to orders. [Google Data Agent Kit with social data](/blog/google-data-agent-kit-bigquery-social-data) covers the table design on the BigQuery side. A third post, [SMS MCP review alerts](/blog/sms-mcp-review-alerts-google-maps-app-reviews), sends alerts after it dedupes on review ID.

This post covers the Databricks side. It explains what each of the three Genie MCP routes can do. It shows how a table fills the gap while the Genie Agent docs do not mention custom MCP. It shows how a Delta `MERGE` handles company replies that arrive later. It also shows why Trustpilot invited and organic reviews need separate treatment. To turn review data into a product, see [how to productize review data](/blog/review-data-productization).

## Recent news

- November 11, 2026: Databricks launched the second-generation Genie. It also released Genie plugins for ChatGPT, Claude, Microsoft Copilot Cowork and Grok Bot ([plugin blog](https://www.databricks.com/blog/bring-your-business-context-chatgpt-claude-microsoft-copilot-cowork-and-grok-bot)). [Genie Ontology became generally available](https://www.databricks.com/blog/announcing-ga-genie-ontology) on the same day. For you, this means other agents can read your warehouse through Genie. Adding outside data to the warehouse is still your job.
- November 12, 2026: The [AI/BI and Genie One release notes](https://docs.databricks.com/aws/en/ai-bi/release-notes/2026) say that the Genie Agent settings page has a separate connectors section (Beta). Genie One scheduled tasks can also email other people. A daily review brief can go straight to the team.
- November 5, 2026: The same release notes describe a change for users with access to only some MCP connections on a Genie Agent. These users are no longer blocked. The agent answers from the sources that the user can access. You can grant the review table and the connectors to different teams.
- November 2, 2026: The release notes say that a Genie Agent can analyze files in Unity Catalog volumes (Public Preview). Examples are PDFs, slide decks and images. Answers cite the source page. Review screenshots or store photos could join the same agent later. Structured fields such as stars and dates still belong in a table.
- October 29, 2026: The release notes add a guided flow for creating a Genie Agent. A team that builds its first review agent can follow it, then add the example SQL from this article.
- November 30, 2026 (coming): The old Beta Genie MCP endpoint `/api/2.0/mcp/genie` stops working ([Genie One MCP docs](https://docs.databricks.com/aws/en/agents/mcp-tools/genie-mcp)). Teams that connect Claude or Cursor through the old address must move to the Unity Gateway URL before the end of the month. The OAuth scope changes from `genie` to `ai-gateway`.
- October 20, 2026: Databricks introduced [agent memory](https://www.databricks.com/blog/introducing-agent-memory-databricks) in Agent Bricks. State such as "which reviews we already read" may move to the platform later. We still suggest keeping the raw reviews in a table.

## FAQ

**Where do I find the Databricks Genie MCP server URL?**

In your workspace, open Unity Gateway and then MCPs. The list shows every MCP and its URL. The Genie MCP server address is `https://<workspace-hostname>/ai-gateway/mcp-services/system.ai.genie_one_mcp?o=<workspace-id>`. Take the workspace ID from the `o=` part of your workspace URL ([Genie One MCP docs](https://docs.databricks.com/aws/en/agents/mcp-tools/genie-mcp)).

**How do I set up OAuth for the Databricks Genie MCP?**

To call the Genie One MCP, any Databricks token in an `Authorization: Bearer` header works. That includes OAuth U2M, OAuth M2M and personal access tokens. On-behalf-of-user OAuth needs the `ai-gateway` scope. In the other direction, when Genie calls an outside MCP such as EveryInfra, the auth comes from the Unity Catalog HTTP connection. A bearer token is enough for EveryInfra.

**Can a Databricks Genie Agent use my own MCP server?**

The docs mark MCP connectors in Genie Agents as Beta. They list nine built-in Databricks connectors and do not mention custom MCP (read on November 14, 2026; page updated November 9). The custom MCP setup is in the Genie One docs. To give a Genie Agent outside data, the route that we can confirm is to land it in a Unity Catalog table first.

**How does Databricks Genie Agent pricing work?**

User activity is free until January 31, 2027, and service principals pay standard rates (details in "The cost of one run per day"). The same Genie docs page says that Genie Code moved to pay-as-you-go on July 8, 2026, with a monthly free allowance per user. SQL warehouse compute is always billed separately. The press release says that you pay for usage, not per seat. Admins can set spending limits per team or user in Unity Gateway.

**Can the Databricks Genie Agent API call MCP connectors?**

It can call read tools. It cannot call write tools, and it cannot complete connector sign-in. Approval for write tools and sign-in both happen in the UI ([Limitations section of the docs](https://docs.databricks.com/aws/en/genie-agents/external-tools)). If your app asks a Genie Agent with connectors through the API, ask users to authorize the connectors in the UI first.

## Getting started

1. Sign up in the [EveryInfra console](/docs#quickstart) and get an API key. Top up or use the trial credit. See the [pricing page](/pricing).
1. In the [capability catalog](/market), check the parameters and current prices of `trustpilot/reviews`, `google_play/reviews` and `reddit/subreddit_posts`. You can also read the capability pages: [Trustpilot reviews](/trustpilot-api/reviews), [Google Play reviews](/google-play-api/reviews), [Reddit subreddit posts](/reddit-api/subreddit_posts) and [Reddit search](/reddit-api/search).
1. Run the Python sample from route 2 once on your machine. Check that all three capabilities return rows and that `charged_usd` matches the catalog.
1. In Databricks, put the key in a secret scope. Create the `public_brand_reviews` table and the job, and run it daily.
1. If people need live answers in Genie One, register the remote MCP as in route 1. See the [MCP server page](/mcp-server) for EveryInfra MCP details.

Platform overview pages: [Trustpilot API](/trustpilot-api), [Google Play API](/google-play-api) and [Reddit API](/reddit-api).

## References

We opened and checked every page below on November 14, 2026 (Singapore time). The date is the publish date. If a page has no publish date, we give its update date or the date we read it. Items 1 to 33 are cited in the text. The rest are extra pages that we checked while writing.

1. [Databricks Launches New Always-on Genie: Autonomous AI for Complex Enterprise Work](https://www.databricks.com/company/newsroom/press-releases/databricks-launches-new-always-genie-autonomous-ai-complex) — Databricks, 2026-11-11
1. [The new Genie: autonomous AI for complex enterprise work](https://www.databricks.com/blog/new-genie-autonomous-ai-complex-enterprise-work) — Databricks, 2026-11-11
1. [Genie One MCP server](https://docs.databricks.com/aws/en/agents/mcp-tools/genie-mcp) — Databricks Docs, 2026-11-12
1. [The Genie One MCP is now Generally Available](https://www.databricks.com/blog/genie-one-mcp-now-generally-available) — Databricks, 2026-09-22
1. [Connect Genie One to external applications with MCP](https://docs.databricks.com/aws/en/genie-one/external-sources) — Databricks Docs, 2026-11-09
1. [External MCP servers](https://docs.databricks.com/aws/en/ai-gateway/register-mcp-service) — Databricks Docs, 2026-10-27
1. [Transports: Streamable HTTP](https://modelcontextprotocol.io/specification/latest/basic/transports/streamable-http) — Model Context Protocol, 2026-11-14
1. [Connect to external HTTP services](https://docs.databricks.com/aws/en/query-federation/http) — Databricks Docs, 2026-11-14
1. [Connect a Genie Agent to MCP tools and sources](https://docs.databricks.com/aws/en/genie-agents/external-tools) — Databricks Docs, 2026-11-09
1. [ai_enrich function](https://docs.databricks.com/aws/en/sql/language-manual/functions/ai_enrich) — Databricks Docs, 2026-11-14
1. [Genie Agents concepts](https://docs.databricks.com/aws/en/genie-agents/concepts) — Databricks Docs, 2026-11-14
1. [Set up and manage a Genie Agent](https://docs.databricks.com/aws/en/genie-agents/set-up) — Databricks Docs, 2026-11-14
1. [Curate an effective Genie Agent](https://docs.databricks.com/aws/en/genie-agents/best-practices) — Databricks Docs, 2026-11-14
1. [Trustpilot's review labels](https://help.trustpilot.com/s/article/About-Trustpilots-review-labels?language=en_US) — Trustpilot Help Center, 2026-11-14
1. [Use liquid clustering for tables](https://docs.databricks.com/aws/en/delta/clustering) — Databricks Docs, 2026-11-14
1. [Upsert into a Delta Lake table using merge](https://docs.databricks.com/aws/en/delta/merge) — Databricks Docs, 2026-11-14
1. [Isolation levels and write conflicts](https://docs.databricks.com/aws/en/optimizations/isolation-level) — Databricks Docs, 2026-11-14
1. [Row-level concurrency](https://docs.databricks.com/aws/en/optimizations/isolation/row-level-concurrency) — Databricks Docs, 2026-11-14
1. [Govern an MCP](https://docs.databricks.com/aws/en/ai-gateway/govern-mcp-service) — Databricks Docs, 2026-11-14
1. [Secret management](https://docs.databricks.com/aws/en/security/secrets/) — Databricks Docs, 2026-11-14
1. [Run jobs on a schedule](https://docs.databricks.com/aws/en/jobs/scheduled) — Databricks Docs, 2026-11-14
1. [Monitor a Genie Agent](https://docs.databricks.com/aws/en/genie-agents/monitor) — Databricks Docs, 2026-11-14
1. [Row filters and column masks](https://docs.databricks.com/aws/en/data-governance/unity-catalog/filters-and-masks/) — Databricks Docs, 2026-11-14
1. [Chat in Genie One](https://docs.databricks.com/aws/en/genie-one/chat) — Databricks Docs, 2026-11-14
1. [Genie](https://docs.databricks.com/aws/en/genie) — Databricks Docs, 2026-11-14
1. [Genie pricing](https://www.databricks.com/product/pricing/genie) — Databricks, 2026-11-14
1. [Monitor and understand your Genie cost](https://learn.microsoft.com/en-us/azure/databricks/genie/monitor-cost) — Microsoft Learn, 2026-11-14
1. [Data API Terms](https://redditinc.com/policies/data-api-terms) — Reddit, Inc., 2026-11-14
1. [Guidelines for reviewers](https://legal.trustpilot.com/for-reviewers/guidelines-for-reviewers) — Trustpilot, 2026-11-14
1. [Bring your business context to ChatGPT, Claude, Microsoft Copilot Cowork and Grok Bot](https://www.databricks.com/blog/bring-your-business-context-chatgpt-claude-microsoft-copilot-cowork-and-grok-bot) — Databricks, 2026-11-11
1. [Announcing GA of Genie Ontology](https://www.databricks.com/blog/announcing-ga-genie-ontology) — Databricks, 2026-11-11
1. [AI/BI and Genie One release notes 2026](https://docs.databricks.com/aws/en/ai-bi/release-notes/2026) — Databricks Docs, 2026-11-12
1. [Introducing Agent Memory on Databricks](https://www.databricks.com/blog/introducing-agent-memory-databricks) — Databricks, 2026-10-20
1. [View and analyze your app's ratings and reviews](https://support.google.com/googleplay/android-developer/answer/138230) — Play Console Help, 2026-11-14
1. [Trustpilot Developers](https://developers.trustpilot.com/) — Trustpilot, 2026-11-14
1. [EveryInfra social catalog](https://api.everyinfra.com/api/v1/social/catalog) — EveryInfra, 2026-11-14
1. [MCP Apps overview](https://modelcontextprotocol.io/extensions/apps/overview) — Model Context Protocol, 2026-11-14
1. [Host an MCP server on Databricks Apps](https://docs.databricks.com/aws/en/agents/mcp-tools/custom-mcp) — Databricks Docs, 2026-11-12
1. [MCP authentication](https://docs.databricks.com/aws/en/agents/mcp-tools/authentication-networking) — Databricks Docs, 2026-11-14
1. [MCP networking](https://docs.databricks.com/aws/en/agents/mcp-tools/networking) — Databricks Docs, 2026-11-14
1. [Supported coding and work agents](https://docs.databricks.com/aws/en/ai-gateway/coding-agent-supported-agents) — Databricks Docs, 2026-11-14
1. [Databricks-provided MCPs](https://docs.databricks.com/aws/en/agents/mcp-tools/built-in-mcp-services) — Databricks Docs, 2026-11-14
1. [Analyze files in volumes with a Genie Agent](https://docs.databricks.com/aws/en/genie-agents/volumes) — Databricks Docs, 2026-11-14
1. [Databricks AI assistive features trust and safety](https://docs.databricks.com/aws/en/databricks-ai/databricks-ai-trust) — Databricks Docs, 2026-11-14
1. [Get access to data products and MCP servers in Databricks Marketplace](https://docs.databricks.com/aws/en/marketplace/get-started-consumer) — Databricks Docs, 2026-11-14
1. [Monitor Genie Code and Genie One with the unified trace table](https://docs.databricks.com/aws/en/ai-gateway/genie-traces) — Databricks Docs, 2026-11-05
1. [MERGE INTO](https://docs.databricks.com/aws/en/sql/language-manual/delta-merge-into) — Databricks Docs, 2026-11-14
1. [Call MCP tools from a Python agent](https://docs.databricks.com/aws/en/agents/custom-agents/use-mcp-tools) — Databricks Docs, 2026-11-14
1. [Databricks' new AI agent tells CEO Ali Ghodsi the unvarnished truth](https://techcrunch.com/2026/11/11/databricks-new-ai-agent-tells-ceo-ali-ghodsi-the-unvarnished-truth/) — TechCrunch, 2026-11-11
1. [Databricks turns Genie into always-on agent for complex work](https://www.techtarget.com/news/databricks-turns-genie-into-always-on-agent-for-complex-work/874354/) — TechTarget, 2026-11-11
1. [Databricks Launches Native Genie Plugins for Four AI Agents](https://www.unite.ai/databricks-launches-native-genie-plugins-for-four-ai-agents/) — Unite.AI, 2026-11-11
1. [Table deletes, updates, and merges](https://docs.delta.io/latest/delta-update.html) — Delta Lake, 2026-11-14
1. [HelloFresh: Meal Kit & Recipes](https://play.google.com/store/apps/details?id=com.hellofresh.androidapp) — Google Play, 2026-11-14
1. [r/hellofresh](https://www.reddit.com/r/hellofresh/) — Reddit, 2026-11-14
1. [Lakeflow Connect](https://docs.databricks.com/aws/en/ingestion/lakeflow-connect/) — Databricks Docs, 2026-11-14
1. [Embed a Genie Agent in an external app](https://docs.databricks.com/aws/en/genie-agents/embed) — Databricks Docs, 2026-11-14
1. [Databricks Designated Services](https://docs.databricks.com/aws/en/resources/designated-services) — Databricks Docs, 2026-11-14
1. [Databricks preview releases](https://docs.databricks.com/aws/en/release-notes/release-types) — Databricks Docs, 2026-11-14