Turn Google Play reviews into design and product decisions

Reviews are the feedback nobody reads

Review Insights is for product designers, UX researchers and product managers who want to go from reviews to decisions they can defend in a design critique or a roadmap meeting: problems ranked by how much they matter, the moments in the journey where people give up, and the users' own words as evidence. Every number links back to the reviews it came from, and every claim quotes the users.

Three layers you can check

Most AI review tools ask a model to summarise the reviews, and you get confident text you can't check. Review Insights splits the work into three layers, so you can trust the result:

1. Evidence. An AI model tags every review: what kind of feedback it is (a bug, a request, friction, a complaint or praise), its themes, the step of the journey it is about, the emotion, how severe it is, who wrote it (new, long-time or paying), whether they are leaving, and anything about accessibility. Risky tags are double-checked: "they're leaving" and a competitor's name are only kept when the review says so in its own words.
2. Analysis, computed in code. Counts, shares, trends and scores are calculated, never written by the model. Impact is reach × negativity × momentum; priority is impact × confidence ÷ effort. Labels like better or worse come from the numbers.
3. Decisions, written by AI and checked. The model explains and recommends, citing the reviews it used. Any citation to a review that doesn't exist is removed, so every claim points to real feedback.

Pick an app, and what you want to learn

An analysis starts from a goal rather than a long form:

• Health check: what do users love and hate right now?
• What's broken: what made people angry this month?
• Recent changes: how did the last few weeks go?
• Deep dive: everything from the last quarter, for research.

The market, the language and the number of reviews have sensible defaults you can change: up to 2,000 reviews, any period, a rating filter, and insights in a different language from the reviews if you need them. It shows the estimated time and tokens before it starts.

Fifteen views, one set of reviews

Every analysis opens in fifteen views, grouped by what they are for:

• Decide: decisions ranked now, next and later, a research report you can download as Markdown or PDF, and your pinned quotes.
• Understand: an overview, problems and priorities, bugs, requests and complaints, a journey map, emotions, segments, risks, accessibility, developer replies and personas.
• Track: trends, one-star spikes, and what changed before and after a release.
• Evidence: every review, filterable by rating, theme, type, journey stage, emotion, version or text.

For a product designer or a UX researcher, that means usability problems ranked by impact rather than by how loud they are, each with quotes for the next critique; How Might We questions, likely root causes and draft proto-personas, marked as hypotheses; and the accessibility barriers users report, grouped by need, each with the WCAG check to run.

For a product manager, it means a prioritised decision list with a metric to watch and a status to track, what got better or worse in the last release, early warnings when people say they're leaving, and output ready for stakeholders.

Ask it, and it looks things up

The assistant, Ask AI, sits beside every analysis. It works from your data, not from memory: to answer, it reads the problem board, the journey map, segments, trends and risks, and searches the reviews, and you can watch each lookup as it happens. Numbers come from those lookups, and every claim is cited: press a citation to read the review it came from.

Each analysis gets up to five starter questions, written from what it found and tagged with why they're there:

A typical decision goes like this:

1. Ask a starter question: "Why are users unhappy about login issues?"
2. Read the cited reviews, and pin the ones that make the case.
3. Narrow it down: "Is this worse for paying users?"
4. Turn it into options: "What are three ways to fix this, cheapest first?"
5. Check the ranked decisions, set their status, and share the research report, with your pinned quotes in it.

Chats open as tabs, so several threads can run at once, and each analysis keeps its own history, so the context of one app never mixes with another's.

Next to the competition

Benchmark puts two to four analyses side by side: your app against competitors, two markets, or two periods. The AI groups each app's themes into shared topics; the leads, lags and lessons are computed from the reviews, each with a quote from both sides.

Claude, ChatGPT, Cursor and more, through MCP

Review Insights includes an MCP server. MCP, the Model Context Protocol, is the standard way for an AI app to use another tool's data. Connected, the AI app you already pay for can read your analyses and answer with numbers and real quotes, using your own subscription. It can only read: it can't start an analysis or change anything.

The easiest way in is that page, in the app's sidebar. The setup, by app:

• Claude Desktop: add the server to claude_desktop_config.json (Settings, Developer, Edit config) and restart. Claude starts it itself, so Review Insights doesn't need to be open.
• Claude Code: one command, below. Codex CLI: the same, in ~/.codex/config.toml.
• Cursor and VS Code: point them at the running app's address, http://localhost:8000/mcp/, and keep Review Insights running.
• ChatGPT or claude.ai in the browser: web apps can only reach the public internet, so expose the app through a tunnel (Cloudflare Tunnel or ngrok), allow that address, and add it as a custom connector. Stop the tunnel when you're done: anyone with its address can read your analyses.

claude mcp add review-insights --scope user \
  --env PYTHONPATH="/path/to/google-play-scrapper-for-designers" \
  -- "/path/to/google-play-scrapper-for-designers/.venv/bin/python" -m backend.mcp_server

Connected, the AI app can list your analyses; read the overview, problems, journey map, segments, trends, risks, accessibility and developer replies; search the reviews for quotes; compute metrics; and compare analyses side by side. Things to ask it:

• "What are the biggest problems in my latest Pokémon GO analysis?"
• "Compare my app with the competitor analyses and list where we lag."
• "Write three Jira tickets for the top problems, with quotes as evidence."

Free, and on your own computer

Anybody can run it. It's free, MIT-licensed, and the code and the full guide are on GitHub (opens in a new tab). You need Python 3.11 or newer, Node.js 24, and an AI model: an API key, a ChatGPT Plus or Pro sign-in, an OpenRouter account, or a local model in Ollama.

git clone https://github.com/ux-biswarup/google-play-scrapper-for-designers.git
cd google-play-scrapper-for-designers
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
cd web && npm install && npm run build && cd ..
uvicorn backend.main:app --port 8000

Then open http://127.0.0.1:8000:

1. Connect an AI model from the bottom of the sidebar: paste a key (Anthropic, OpenAI, Gemini, OpenRouter, Groq, Mistral or any OpenAI-compatible server), continue with ChatGPT, connect OpenRouter, or point it at Ollama.
2. Analyze an app: New analysis, find the app, pick a goal, start.
3. Explore and ask: browse the views, and open Ask AI.

Your reviews and keys stay yours

• It runs locally. Reviews and results stay on your computer. Reviews are sent only to the AI provider you choose, and with Ollama, nowhere at all.
• Keys never live in the browser. The ones you paste are encrypted on disk, and the encryption key is kept in your system's keychain. The app only shows a masked hint.
• Other websites can't use them. The server answers only on your own machine, and refuses changes requested by other websites.
• The MCP server is local too, unless you choose to open it through a tunnel.

Why it works the way it does

The AI writes; the numbers are computed. A number a model writes cannot be checked. A number computed from tagged reviews links back to the reviews it came from, so it can be defended in a critique.

Every claim quotes the users. A finding with a review under it is evidence; a finding without one is an opinion. The model is told never to invent numbers, themes or quotes, and the code drops any citation that does not point at a real review.

Any model, with your own key. It works with Anthropic, OpenAI, Google Gemini, OpenRouter, Groq, Mistral, a ChatGPT plan, any OpenAI-compatible server, or Ollama on your own machine, where no review leaves it. Keys stay out of the browser and encrypted on your computer.

Free and open source. It is MIT-licensed and runs on your own computer, so anyone can use it, check how it reaches a number, or change it.

Sentiment tells you how people feel. Review Insights tells you what to do about it.