Turns thousands of scattered customer reviews into a churn-risk-ranked, engineering-ready product roadmap — automatically.
-orange.svg){kind=icon}
Product teams drown in feedback long before they run out of ideas. Thousands of App Store, Play Store, G2, Trustpilot, and Reddit reviews pile up, and the handful of comments that actually predict churn get buried under noise. Manually triaging that volume into a defensible "build this next" list doesn't scale.
FeedbackX runs a small pipeline of purpose-built agents that turn raw review text into a prioritized, numbers-backed roadmap:
graph LR
A[Customer Reviews<br/>5 platforms] --> B[ScraperAgent<br/>ingest & dedupe]
B --> C[AnalyzerAgent<br/>aspect-based sentiment<br/>+ churn risk scoring]
C --> D[InsightAgent<br/>RICE-scored roadmap]
D --> E[Executive Summary<br/>+ prioritized feature list]
ScraperAgentingests customer reviews from multiple platforms (App Store, Google Play, G2, Trustpilot, Reddit). The bundled demo uses a deterministic, reproducible review generator rather than live scraping — see Design notes for why.AnalyzerAgentperforms real Aspect-Based Sentiment Analysis: it clusters reviews into product aspects by keyword, then scores each cluster's sentiment and churn risk from a blend of star rating and a lightweight sentiment lexicon — not fixed numbers.InsightAgentscores every aspect with an actual RICE formula (Reach × Impact × Confidence ÷ Effort), sorts the roadmap by that score, and estimates churn reduction per shipped item.FeedbackXEnginesynthesizes an executive summary from the computed metrics, optionally enriched by a free, locally-run LLM (see below) — and always falls back to a deterministic, template-built summary if that LLM isn't available.
The result changes with the input: feed it a different review count or mix, and the aspect clusters, RICE scores, and roadmap ordering move with it — nothing here is hardcoded demo output.
The executive summary can optionally be enriched by Ollama, running a small open model (llama3.2 by default) entirely on your own machine — no API key, no account, no per-token billing.
- Off by default. With
FEEDBACKX_ENABLE_LLMunset, FeedbackX runs its deterministic summary path and never attempts a network call. - Fails soft. If Ollama isn't running, isn't reachable, or times out,
OllamaProviderreturnsNoneand the deterministic summary is used instead — the API never errors because of it. Seefeedbackx/core/llm_provider.pyandtests/test_llm_provider.py. - Transparent in the UI. The dashboard's header pill calls
GET /api/v1/system/llm-statusand shows whether enrichment is active, off, or configured-but-unreachable.
feedbackx-hazel.vercel.app — deployed straight from this repo's main branch on Vercel's free tier. It runs the real ABSA/RICE pipeline against live requests; the executive summary uses the deterministic path since Vercel's serverless functions have no persistent Ollama process to reach (see below for that part running locally).
The whole stack — API, dashboard, and a real local LLM — runs from one command, no cloud account or API key required.
git clone https://github.com/asadullah48/feedbackx.git
cd feedbackx
docker compose up --buildThen open http://localhost:8020. The first run pulls the llama3.2 model in the background (a few minutes, once) via the ollama-pull service; the dashboard works immediately in the meantime and simply falls back to deterministic summaries until the model is ready.
Run without Docker (deterministic mode only)
python -m venv .venv && .venv/Scripts/activate # or: source .venv/bin/activate
pip install -e ".[dev]"
uvicorn feedbackx.server:app --host 0.0.0.0 --port 8020To enable LLM enrichment this way too, install Ollama locally, run ollama pull llama3.2, copy .env.example to .env, and set FEEDBACKX_ENABLE_LLM=true.
| Method | Path | Description |
|---|---|---|
GET |
/ |
Bilingual (English / Arabic RTL) dashboard |
POST |
/api/v1/feedback/generate-intelligence?review_count=1500 |
Run the full pipeline, return a MarketIntelligenceReport |
GET |
/api/v1/feedback/sample-reviews?count=10 |
Raw sample reviews, unanalyzed |
GET |
/api/v1/system/llm-status |
Whether Ollama enrichment is enabled/reachable |
GET |
/healthz, /readyz |
Liveness / readiness probes |
GET |
/docs |
Interactive OpenAPI docs (Swagger UI) |
pip install -e ".[dev]"
pytest13 tests cover the analyzer's sentiment/churn math, the RICE prioritization logic, the LLM provider's fail-soft behavior (including a real unreachable-host case), and the API surface.
feedbackx/
├── agents/ # ScraperAgent, AnalyzerAgent, InsightAgent
├── core/
│ ├── review_scraper_engine.py # deterministic multi-platform review generator
│ ├── aspect_sentiment_analyzer.py # keyword clustering + sentiment/churn scoring
│ ├── llm_provider.py # optional Ollama enrichment, fails soft
│ └── models.py # Pydantic schemas
├── orchestration/feedbackx_engine.py # wires the pipeline together
├── static/ # bilingual glassmorphism dashboard (HTML/CSS/JS)
└── server.py # FastAPI app
Also included: a Dockerfile + docker-compose.yml (app + Ollama, used above), a Helm chart under helm/ for a Kubernetes deployment path, and vercel.json for the hosted demo.
- Why a synthetic review generator instead of live scraping App Store/G2/Trustpilot? Those platforms require paid API access or violate their terms of service to scrape directly.
ReviewScraperEnginegenerates realistic, reproducible review text instead, soAnalyzerAgentandInsightAgenthave real (if synthetic) text to compute against — the analysis and prioritization logic downstream is genuine, not the ingestion source. - Why a keyword lexicon instead of a heavier NLP model for sentiment? It keeps the core pipeline dependency-light and instant, with zero inference cost — appropriate for a free-tier project. The optional Ollama layer is the upgrade path for genuinely LLM-generated prose (the executive summary), while the numeric scoring (sentiment, churn risk, RICE) stays deterministic and auditable either way.
Apache License 2.0 — see LICENSE.
Built by Asadullah Shafique · العربية