Shipping customer feedback to an external API is the default move, and also the one that gets flagged in security reviews. Your users are telling you exactly what's broken. They're just doing it in 500 different ways at once. This tutorial builds a self-contained alternative: feedback files land in Civo Object Store, a local LLM running on a Civo GPU node extracts themes, complaints, and feature requests, and a React dashboard surfaces the results. Nothing leaves your cluster.

What we’re building in this tutorial

Throughout this tutorial, we will be focused on 7 core points to build a self-contained customer feedback theme extractor:

Upload a feedback CSV to Civo Object Store
An inference worker running in the cluster polls for new files every 30 seconds
It sends the feedback text to Llama 3 running locally on a Civo GPU node via Ollama
Llama 3 returns structured JSON. Themes, complaints, feature requests, and sentiment
The worker saves those results back to Object Store
A FastAPI service reads the results and aggregates them across all batches
A React dashboard fetches the summary and displays it. Accessible via a public LoadBalancer IP

No customer data leaves your infrastructure at any point.

Prerequisites

Project structure

Before you start, create this folder structure on your machine. You can do it in Finder or run mkdir -p in your terminal; either works. All files that we are going to create in later steps go here.

1feedback-extractor/
2├── inference-worker/
3│   ├── Dockerfile
4│   ├── requirements.txt
5│   ├── prompts.py
6│   └── worker.py
7├── dashboard-api/
8│   ├── Dockerfile
9│   ├── requirements.txt
10│   └── main.py
11└── dashboard-ui/
12    ├── Dockerfile
13    ├── nginx.conf
14    └── src/
15        ├── App.jsx
16        └── App.css

Step 1: Install the CLI tools

Check what you already have:

1civo version
2kubectl version --client

Install anything missing:

1brew install civo kubectl

Install boto3 for Object Store uploads:

1pip3 install boto3 --break-system-packages

Authenticate the Civo CLI with your API key. Grab it from your dashboard under Profile → Security:

1civo apikey save default <your-api-key>
2civo apikey use default

Step 2: Create the Object Store Bucket

1civo objectstore create feedback-data --region NYC1

Once provisioned, get the access key:

1civo objectstore show feedback-data --region NYC1

Then fetch the secret:

1civo objectstore credential secret --access-key <access-key-from-above>

Export everything:

1export CIVO_ACCESS_KEY="<your-access-key>"
2export CIVO_SECRET_KEY="<your-secret-key>"
3export CIVO_ENDPOINT="https://objectstore.nyc1.civo.com"

Step 3: Upload your first feedback file

In VS Code, create a file at ~/Desktop/feedback-extractor/feedback.csv and paste this in:

1id,source,text,date
21,app_store,"The dashboard takes forever to load on large datasets",2024-01-01
32,support,"Can you add dark mode? My eyes hurt after long sessions",2024-01-01
43,support,"Billing page crashed when I tried to update my card",2024-01-02
54,app_store,"Love the new API docs, very clear and well structured",2024-01-02
65,survey,"Please add CSV export to every table not just the main one",2024-01-03
76,support,"Two-factor authentication keeps logging me out randomly",2024-01-03
87,app_store,"The onboarding flow is confusing, couldn't find where to invite teammates",2024-01-04
98,support,"Your Slack integration is broken since last Tuesday",2024-01-04
109,survey,"Would love a mobile app, the mobile browser experience is rough",2024-01-05
1110,app_store,"Pricing is not competitive compared to alternatives",2024-01-05
1211,support,"Dashboard takes forever to load, please fix this",2024-01-06
1312,survey,"Dark mode would be amazing, please add it",2024-01-06
1413,app_store,"CSV export is missing from the reports section",2024-01-07
1514,support,"Got charged twice this month, billing is broken",2024-01-07
1615,survey,"The mobile experience is terrible, need a proper app",2024-01-08
1716,app_store,"Slack integration stopped working after your last update",2024-01-08
1817,support,"Loading times are unacceptable on our dataset size",2024-01-09
1918,survey,"Please add dark mode it would really help usability",2024-01-09
2019,support,"Onboarding needs a complete rework, very confusing",2024-01-10
2120,app_store,"Two-factor auth is unreliable, keeps kicking me out",2024-01-10

Upload it to the raw/ prefix:

1cd ~/Desktop/feedback-extractor
2
3python3 -c "
4import boto3
5from botocore.config import Config
6s3 = boto3.client('s3',
7    endpoint_url='$CIVO_ENDPOINT',
8    aws_access_key_id='$CIVO_ACCESS_KEY',
9    aws_secret_access_key='$CIVO_SECRET_KEY',
10    config=Config(request_checksum_calculation='when_required', response_checksum_validation='when_required')
11)
12with open('feedback.csv', 'rb') as f:
13    s3.put_object(Bucket='feedback-data', Key='raw/feedback.csv', Body=f.read())
14print('done')
15"

Step 4: Create the Kubernetes cluster

We'll create the cluster using the Civo dashboard, which gives us direct access to GPU node sizes without any additional setup.

Go to dashboard.civo.com and log in
Click Kubernetes → New Cluster
Name it “feedback-cluster”
Under Node Pools, select Nvidia L40S 40GB Small (an.g1.l40s.kube.x1)
Click Create Cluster
Once ready, download the kubeconfig from the cluster page

Save the kubeconfig:

1civo kubernetes config feedback-cluster --save --overwrite --region NYC1

Verify the node is up:

1kubectl get nodes

Label it so we can pin Ollama to it later on:

1kubectl label node <node-name> gpu=true

Replace <node-name> with the name from kubectl get nodes.

Step 5: Deploy Ollama on the GPU node

Put a brain on the GPU. Once we have created our new GPU node, we want to install our Llama model on it.

In VS Code, create ollama.yaml directly inside ~/Desktop/feedback-extractor/ and paste this in:

1apiVersion: v1
2kind: Namespace
3metadata:
4  name: inference
5---
6apiVersion: apps/v1
7kind: Deployment
8metadata:
9  name: ollama
10  namespace: inference
11spec:
12  replicas: 1
13  selector:
14    matchLabels:
15      app: ollama
16  template:
17    metadata:
18      labels:
19        app: ollama
20    spec:
21      nodeSelector:
22        gpu: "true"
23      containers:
24        - name: ollama
25          image: ollama/ollama:latest
26          ports:
27            - containerPort: 11434
28          volumeMounts:
29            - name: ollama-data
30              mountPath: /root/.ollama
31      volumes:
32        - name: ollama-data
33          emptyDir: {}
34---
35apiVersion: v1
36kind: Service
37metadata:
38  name: ollama
39  namespace: inference
40spec:
41  selector:
42    app: ollama
43  ports:
44    - port: 11434
45      targetPort: 11434

Apply it:

1kubectl apply -f ~/Desktop/feedback-extractor/ollama.yaml
2kubectl -n inference rollout status deployment/ollama

Pull Llama 3 onto the pod. This might take a couple of minutes:

1OLLAMA_POD=$(kubectl -n inference get pods -l app=ollama -o jsonpath='{.items[0].metadata.name}')
2kubectl -n inference exec -it "$OLLAMA_POD" -- ollama pull llama3

Sanity check:

1kubectl -n inference exec -it "$OLLAMA_POD" -- ollama run llama3 "Reply with one word: working"

Step 6: Build and deploy the inference worker

The inference worker is a Python script that runs as a pod inside the cluster in an infinite loop. It has one job: watch the Object Store for new feedback files, process them through the LLM, and save the results back. It has no HTTP endpoints, and nothing talks to it directly; it just runs quietly in the background, picking up files as they arrive and writing results when done.

Open inference-worker/ in VS Code and create the following four files.

inference-worker/requirements.txt

1boto3==1.34.0
2httpx==0.27.0
3pydantic==2.6.0
4tenacity==8.2.3

inference-worker/prompts.py

1SYSTEM_PROMPT = """You are a product analyst. Your job is to read batches of customer
2feedback and extract structured insights. Always respond with valid JSON only —
3no markdown, no explanation, just the JSON object."""
4
5
6def build_extraction_prompt(feedback_texts: list[str]) -> str:
7    joined = "\n---\n".join(feedback_texts)
8    return f"""Analyse the following {len(feedback_texts)} customer feedback items.
9
10{joined}
11
12Return a JSON object with this exact structure:
13{{
14  "themes": [
15    {{"name": "theme name", "count": <int>, "description": "one sentence", "example_quotes": ["quote1", "quote2"]}}
16  ],
17  "complaints": [
18    {{"title": "complaint title", "frequency": "high|medium|low", "affected_area": "area"}}
19  ],
20  "feature_requests": [
21    {{"feature": "feature name", "demand_score": <1-10>, "context": "brief context"}}
22  ],
23  "sentiment_breakdown": {{
24    "positive": <percentage int>,
25    "neutral": <percentage int>,
26    "negative": <percentage int>
27  }}
28}}"""

inference-worker/worker.py

1import json
2import logging
3import os
4import time
5
6import boto3
7import httpx
8from tenacity import retry, stop_after_attempt, wait_exponential
9
10from prompts import SYSTEM_PROMPT, build_extraction_prompt
11
12logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
13log = logging.getLogger(__name__)
14
15BUCKET           = os.environ["OBJECT_STORE_BUCKET"]
16ENDPOINT         = os.environ["OBJECT_STORE_ENDPOINT"]
17ACCESS_KEY       = os.environ["OBJECT_STORE_ACCESS_KEY"]
18SECRET_KEY       = os.environ["OBJECT_STORE_SECRET_KEY"]
19OLLAMA_URL       = os.environ.get("OLLAMA_URL", "http://ollama.inference.svc.cluster.local:11434")
20OLLAMA_MODEL     = os.environ.get("OLLAMA_MODEL", "llama3")
21CHUNK_SIZE       = int(os.environ.get("CHUNK_SIZE", "25"))
22RAW_PREFIX       = "raw/"
23PROCESSED_PREFIX = "processed/"
24
25s3 = boto3.client(
26    "s3",
27    endpoint_url=ENDPOINT,
28    aws_access_key_id=ACCESS_KEY,
29    aws_secret_access_key=SECRET_KEY,
30)
31
32def list_unprocessed_files() -> list[str]:
33    raw_keys = {
34        obj["Key"]
35        for obj in s3.list_objects_v2(Bucket=BUCKET, Prefix=RAW_PREFIX).get("Contents", [])
36        if obj["Key"].endswith(".csv")
37    }
38    done_keys = {
39        obj["Key"].replace(PROCESSED_PREFIX, RAW_PREFIX).replace(".json", ".csv")
40        for obj in s3.list_objects_v2(Bucket=BUCKET, Prefix=PROCESSED_PREFIX).get("Contents", [])
41    }
42    return sorted(raw_keys - done_keys)
43
44
45def download_feedback(key: str) -> list[dict]:
46    import csv, io
47    body = s3.get_object(Bucket=BUCKET, Key=key)["Body"].read().decode()
48    return list(csv.DictReader(io.StringIO(body)))
49
50
51def upload_results(results: dict, source_key: str) -> None:
52    out_key = source_key.replace(RAW_PREFIX, PROCESSED_PREFIX).replace(".csv", ".json")
53    s3.put_object(
54        Bucket=BUCKET,
55        Key=out_key,
56        Body=json.dumps(results, indent=2).encode(),
57        ContentType="application/json",
58    )
59    log.info(f"Uploaded results to s3://{BUCKET}/{out_key}")
60
61
62@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
63def call_ollama(prompt: str) -> dict:
64    payload = {
65        "model": OLLAMA_MODEL,
66        "messages": [
67            {"role": "system", "content": SYSTEM_PROMPT},
68            {"role": "user",   "content": prompt},
69        ],
70        "stream": False,
71        "format": "json",
72    }
73    resp = httpx.post(f"{OLLAMA_URL}/api/chat", json=payload, timeout=120)
74    resp.raise_for_status()
75    return json.loads(resp.json()["message"]["content"])
76
77
78def merge_chunk_results(chunk_results: list[dict]) -> dict:
79    merged_themes: dict[str, dict] = {}
80    merged_complaints: list[dict] = []
81    merged_requests: dict[str, dict] = {}
82    sentiment_totals = {"positive": 0, "neutral": 0, "negative": 0}
83
84    for result in chunk_results:
85        for theme in result.get("themes", []):
86            name = theme["name"].lower()
87            if name in merged_themes:
88                merged_themes[name]["count"] += theme["count"]
89            else:
90                merged_themes[name] = {**theme}
91
92        seen = {c["title"].lower() for c in merged_complaints}
93        for complaint in result.get("complaints", []):
94            if complaint["title"].lower() not in seen:
95                merged_complaints.append(complaint)
96
97        for fr in result.get("feature_requests", []):
98            key = fr["feature"].lower()
99            if key in merged_requests:
100                merged_requests[key]["demand_score"] = (
101                    merged_requests[key]["demand_score"] + fr["demand_score"]
102                ) / 2
103            else:
104                merged_requests[key] = {**fr}
105
106        for s in ("positive", "neutral", "negative"):
107            sentiment_totals[s] += result.get("sentiment_breakdown", {}).get(s, 0)
108
109    n = len(chunk_results)
110    return {
111        "themes": sorted(merged_themes.values(), key=lambda t: t["count"], reverse=True),
112        "complaints": merged_complaints,
113        "feature_requests": sorted(merged_requests.values(), key=lambda r: r["demand_score"], reverse=True),
114        "sentiment_breakdown": {k: round(v / n) for k, v in sentiment_totals.items()},
115    }
116
117
118def process_file(key: str) -> None:
119    log.info(f"Processing {key}")
120    rows = download_feedback(key)
121    texts = [r["text"] for r in rows if r.get("text")]
122    chunks = [texts[i : i + CHUNK_SIZE] for i in range(0, len(texts), CHUNK_SIZE)]
123
124    chunk_results = []
125    for idx, chunk in enumerate(chunks, 1):
126        log.info(f"  Chunk {idx}/{len(chunks)} ({len(chunk)} items)")
127        chunk_results.append(call_ollama(build_extraction_prompt(chunk)))
128
129    result = merge_chunk_results(chunk_results)
130    result["source_file"] = key
131    result["processed_at"] = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
132    result["total_feedback_items"] = len(texts)
133    upload_results(result, key)
134
135
136def main():
137    log.info("Inference worker started")
138    while True:
139        pending = list_unprocessed_files()
140        if not pending:
141            log.info("No unprocessed files. Sleeping 30s...")
142            time.sleep(30)
143            continue
144        for key in pending:
145            try:
146                process_file(key)
147            except Exception as e:
148                log.error(f"Failed to process {key}: {e}")
149        time.sleep(10)
150
151
152if __name__ == "__main__":
153    main()

inference-worker/Dockerfile

1FROM python:3.11-slim
2WORKDIR /app
3COPY requirements.txt .
4RUN pip install --no-cache-dir -r requirements.txt
5COPY worker.py prompts.py ./
6CMD ["python", "worker.py"]

Now build and push the image.

Apple Silicon: Always build with --platform linux/amd64. The cluster runs AMD64 and will fail to pull an ARM image with a no match for platform in manifest error.

1cd ~/Desktop/feedback-extractor/inference-worker
2
3docker buildx build --platform linux/amd64 \
4  -t <your-dockerhub-username>/feedback-worker:latest --push

Create the credentials secret:

1kubectl -n inference create secret generic objectstore-creds \
2  --from-literal=bucket="feedback-data" \
3  --from-literal=endpoint="https://objectstore.nyc1.civo.com" \
4  --from-literal=access_key="$CIVO_ACCESS_KEY" \
5  --from-literal=secret_key="$CIVO_SECRET_KEY"

In VS Code, create inference-worker/worker-deployment.yaml:

1apiVersion: apps/v1
2kind: Deployment
3metadata:
4  name: inference-worker
5  namespace: inference
6spec:
7  replicas: 1
8  selector:
9    matchLabels:
10      app: inference-worker
11  template:
12    metadata:
13      labels:
14        app: inference-worker
15    spec:
16      containers:
17        - name: worker
18          image: <your-dockerhub-username>/feedback-worker:latest
19          env:
20            - name: OBJECT_STORE_BUCKET
21              valueFrom:
22                secretKeyRef:
23                  name: objectstore-creds
24                  key: bucket
25            - name: OBJECT_STORE_ENDPOINT
26              valueFrom:
27                secretKeyRef:
28                  name: objectstore-creds
29                  key: endpoint
30            - name: OBJECT_STORE_ACCESS_KEY
31              valueFrom:
32                secretKeyRef:
33                  name: objectstore-creds
34                  key: access_key
35            - name: OBJECT_STORE_SECRET_KEY
36              valueFrom:
37                secretKeyRef:
38                  name: objectstore-creds
39                  key: secret_key
40            - name: OLLAMA_URL
41              value: "http://ollama.inference.svc.cluster.local:11434"

Deploy it:

1kubectl apply -f ~/Desktop/feedback-extractor/inference-worker/worker-deployment.yaml
2kubectl -n inference rollout status deployment/inference-worker

Tail the logs to confirm it's working:

1kubectl -n inference logs -f deployment/inference-worker

You should see:

1INFO Inference worker started
2INFO Processing raw/feedback.csv
3INFO   Chunk 1/1 (20 items)
4INFO Uploaded results to s3://feedback-data/processed/feedback.json
5INFO No unprocessed files. Sleeping 30s...

Step 7: Build and deploy the dashboard API

Open dashboard-api/ in VS Code and create three files.

dashboard-api/requirements.txt

1boto3==1.34.0
2fastapi==0.110.0
3uvicorn[standard]==0.29.0

dashboard-api/main.py

1import json
2import os
3
4import boto3
5from fastapi import FastAPI
6from fastapi.middleware.cors import CORSMiddleware
7
8app = FastAPI()
9app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
10
11s3 = boto3.client(
12    "s3",
13    endpoint_url=os.environ["OBJECT_STORE_ENDPOINT"],
14    aws_access_key_id=os.environ["OBJECT_STORE_ACCESS_KEY"],
15    aws_secret_access_key=os.environ["OBJECT_STORE_SECRET_KEY"],
16)
17BUCKET = os.environ["OBJECT_STORE_BUCKET"]
18
19
20def get_all_results() -> list[dict]:
21    objects = s3.list_objects_v2(Bucket=BUCKET, Prefix="processed/").get("Contents", [])
22    return [
23        json.loads(s3.get_object(Bucket=BUCKET, Key=obj["Key"])["Body"].read())
24        for obj in objects if obj["Key"].endswith(".json")
25    ]
26
27
28@app.get("/api/summary")
29def summary():
30    all_results = get_all_results()
31    if not all_results:
32        return {"message": "No processed data yet", "batches_processed": 0}
33
34    theme_map, complaint_map, feature_map = {}, {}, {}
35    sentiment_totals = {"positive": 0, "neutral": 0, "negative": 0}
36    total_items = 0
37
38    for result in all_results:
39        total_items += result.get("total_feedback_items", 0)
40        for theme in result.get("themes", []):
41            theme_map[theme["name"]] = theme_map.get(theme["name"], 0) + theme["count"]
42        for complaint in result.get("complaints", []):
43            complaint_map.setdefault(complaint["title"], complaint)
44        for fr in result.get("feature_requests", []):
45            if fr["feature"] in feature_map:
46                feature_map[fr["feature"]] = (feature_map[fr["feature"]] + fr["demand_score"]) / 2
47            else:
48                feature_map[fr["feature"]] = fr["demand_score"]
49        for s in ("positive", "neutral", "negative"):
50            sentiment_totals[s] += result.get("sentiment_breakdown", {}).get(s, 0)
51
52    n = len(all_results)
53    return {
54        "total_feedback_items": total_items,
55        "batches_processed": n,
56        "themes": sorted([{"name": k, "count": v} for k, v in theme_map.items()], key=lambda x: x["count"], reverse=True),
57        "top_complaints": sorted(list(complaint_map.values()), key=lambda c: {"high": 3, "medium": 2, "low": 1}.get(c["frequency"], 0), reverse=True)[:10],
58        "feature_requests": sorted([{"feature": k, "demand_score": round(v, 1)} for k, v in feature_map.items()], key=lambda x: x["demand_score"], reverse=True)[:10],
59        "sentiment": {k: round(v / n) for k, v in sentiment_totals.items()},
60    }
61
62
63@app.get("/api/batches")
64def list_batches():
65    return get_all_results()
66
67
68@app.get("/healthz")
69def health():
70    return {"status": "ok"}

dashboard-api/Dockerfile

1FROM python:3.11-slim
2WORKDIR /app
3COPY requirements.txt .
4RUN pip install --no-cache-dir -r requirements.txt
5COPY main.py .
6CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

1cd ~/Desktop/feedback-extractor/dashboard-api
2
3docker buildx build --platform linux/amd64 \
4  -t <your-dockerhub-username>/feedback-api:latest --push

In VS Code, create dashboard-api/api-deployment.yaml:

1apiVersion: apps/v1
2kind: Deployment
3metadata:
4  name: dashboard-api
5  namespace: inference
6spec:
7  replicas: 1
8  selector:
9    matchLabels:
10      app: dashboard-api
11  template:
12    metadata:
13      labels:
14        app: dashboard-api
15    spec:
16      containers:
17        - name: api
18          image: <your-dockerhub-username>/feedback-api:latest
19          ports:
20            - containerPort: 8000
21          env:
22            - name: OBJECT_STORE_BUCKET
23              valueFrom:
24                secretKeyRef:
25                  name: objectstore-creds
26                  key: bucket
27            - name: OBJECT_STORE_ENDPOINT
28              valueFrom:
29                secretKeyRef:
30                  name: objectstore-creds
31                  key: endpoint
32            - name: OBJECT_STORE_ACCESS_KEY
33              valueFrom:
34                secretKeyRef:
35                  name: objectstore-creds
36                  key: access_key
37            - name: OBJECT_STORE_SECRET_KEY
38              valueFrom:
39                secretKeyRef:
40                  name: objectstore-creds
41                  key: secret_key
42---
43apiVersion: v1
44kind: Service
45metadata:
46  name: dashboard-api
47  namespace: inference
48spec:
49  selector:
50    app: dashboard-api
51  type: LoadBalancer
52  ports:
53    - port: 80
54      targetPort: 8000

1kubectl apply -f ~/Desktop/feedback-extractor/dashboard-api/api-deployment.yaml
2kubectl -n inference rollout status deployment/dashboard-api
3kubectl -n inference get svc dashboard-api

Wait for EXTERNAL-IP to populate, then test:

1curl http://<EXTERNAL-IP>/api/summary

Step 8: Build and deploy the React dashboard

Node version: Vite 8 requires Node 20.19+ or 22+. Check with node --version. If you're below that, run nvm install 22 && nvm use 22.

cd ~/Desktop/feedback-extractor/dashboard-ui

1npm create vite@latest . -- --template react
2npm install
3npm install recharts

Open dashboard-ui/src/App.jsx in VS Code and replace the entire contents with:

1import { useEffect, useState } from "react";
2import { BarChart, Bar, XAxis, YAxis, Tooltip, ResponsiveContainer } from "recharts";
3import "./App.css";
4
5const API_URL = import.meta.env.VITE_API_URL || "http://<your-api-external-ip>";
6
7const SENTIMENT_COLORS = { positive: "#22c55e", neutral: "#94a3b8", negative: "#ef4444" };
8const FREQUENCY_COLORS = { high: "#ef4444", medium: "#f97316", low: "#eab308" };
9
10function SentimentBar({ data }) {
11  return (
12    <div>
13      <div className="sentiment-labels">
14        {Object.entries(data).map(([key, pct]) => (
15          <span key={key} style={{ color: SENTIMENT_COLORS[key] }}>
16            {key.charAt(0).toUpperCase() + key.slice(1)}: {pct}%
17          </span>
18        ))}
19      </div>
20      <div className="sentiment-bar">
21        {Object.entries(data).map(([key, pct]) => (
22          <div key={key} style={{ width: `${pct}%`, background: SENTIMENT_COLORS[key] }} />
23        ))}
24      </div>
25    </div>
26  );
27}
28
29function StatCard({ label, value }) {
30  return (
31    <div className="stat-card">
32      <div className="stat-value">{value}</div>
33      <div className="stat-label">{label}</div>
34    </div>
35  );
36}
37
38export default function App() {
39  const [summary, setSummary] = useState(null);
40  const [loading, setLoading] = useState(true);
41  const [error, setError] = useState(null);
42  const [lastUpdated, setLastUpdated] = useState(null);
43
44  const load = async () => {
45    try {
46      const res = await fetch(`${API_URL}/api/summary`);
47      if (!res.ok) throw new Error(`HTTP ${res.status}`);
48      setSummary(await res.json());
49      setLastUpdated(new Date());
50      setError(null);
51    } catch (e) {
52      setError(e.message);
53    } finally {
54      setLoading(false);
55    }
56  };
57
58  useEffect(() => {
59    load();
60    const t = setInterval(load, 30000);
61    return () => clearInterval(t);
62  }, []);
63
64  if (loading) return <div className="fullscreen-center"><div className="spinner" /><p>Loading...</p></div>;
65  if (error) return <div className="fullscreen-center"><p>⚠ {error}</p><button onClick={load}>Retry</button></div>;
66  if (!summary || summary.message) return <div className="fullscreen-center"><p>No processed feedback yet.</p></div>;
67
68  return (
69    <div className="dashboard">
70      <header className="dashboard-header">
71        <div>
72          <h1>Customer Feedback Intelligence</h1>
73          <p className="header-meta">
74            Processed on Civo GPU · Last updated {lastUpdated?.toLocaleTimeString()}
75          </p>
76        </div>
77        <button className="refresh-btn" onClick={load}>↻ Refresh</button>
78      </header>
79
80      <div className="stats-row">
81        <StatCard label="Feedback Items" value={summary.total_feedback_items.toLocaleString()} />
82        <StatCard label="Batches" value={summary.batches_processed} />
83        <StatCard label="Themes" value={summary.themes.length} />
84        <StatCard label="Feature Requests" value={summary.feature_requests.length} />
85      </div>
86
87      <section className="card">
88        <h2>Sentiment</h2>
89        <SentimentBar data={summary.sentiment} />
90      </section>
91
92      <section className="card">
93        <h2>Top Themes</h2>
94        <ResponsiveContainer width="100%" height={280}>
95          <BarChart data={summary.themes.slice(0, 8)} layout="vertical" margin={{ left: 10, right: 20 }}>
96            <XAxis type="number" tick={{ fontSize: 12 }} />
97            <YAxis type="category" dataKey="name" width={170} tick={{ fontSize: 12 }} />
98            <Tooltip />
99            <Bar dataKey="count" fill="#6366f1" radius={[0, 4, 4, 0]} />
100          </BarChart>
101        </ResponsiveContainer>
102      </section>
103
104      <div className="two-col">
105        <section className="card">
106          <h2>Complaints</h2>
107          <ul className="complaint-list">
108            {summary.top_complaints.map((c, i) => (
109              <li key={i} className="complaint-item">
110                <span className="badge" style={{ background: FREQUENCY_COLORS[c.frequency] }}>
111                  {c.frequency}
112                </span>
113                <div className="complaint-body">
114                  <span className="complaint-title">{c.title}</span>
115                  <span className="complaint-area">{c.affected_area}</span>
116                </div>
117              </li>
118            ))}
119          </ul>
120        </section>
121
122        <section className="card">
123          <h2>Feature Requests</h2>
124          <table className="feature-table">
125            <thead><tr><th>Feature</th><th>Demand</th></tr></thead>
126            <tbody>
127              {summary.feature_requests.map((fr, i) => (
128                <tr key={i}>
129                  <td>{fr.feature}</td>
130                  <td>
131                    <div className="demand-wrap">
132                      <div className="demand-track">
133                        <div className="demand-fill" style={{ width: `${fr.demand_score * 10}%` }} />
134                      </div>
135                      <span className="demand-score">{fr.demand_score}</span>
136                    </div>
137                  </td>
138                </tr>
139              ))}
140            </tbody>
141          </table>
142        </section>
143      </div>
144    </div>
145  );
146}

Build the production bundle:

1cd ~/Desktop/feedback-extractor/dashboard-ui
2npm run build

In VS Code, create dashboard-ui/Dockerfile:

1FROM nginx:alpine
2COPY dist /usr/share/nginx/html
3COPY nginx.conf /etc/nginx/conf.d/default.conf
4EXPOSE 80

Create dashboard-ui/nginx.conf:

1server {
2    listen 80;
3    root /usr/share/nginx/html;
4    index index.html;
5
6    location / {
7        try_files $uri $uri/ /index.html;
8    }
9
10    location /api/ {
11        proxy_pass http://dashboard-api.inference.svc.cluster.local:8000;
12        proxy_set_header Host $host;
13        proxy_set_header X-Real-IP $remote_addr;
14    }
15}

1docker buildx build --platform linux/amd64 \
2  -t <your-dockerhub-username>/feedback-ui:latest --push

In VS Code, create dashboard-ui/ui-deployment.yaml:

1apiVersion: apps/v1
2kind: Deployment
3metadata:
4  name: dashboard-ui
5  namespace: inference
6spec:
7  replicas: 1
8  selector:
9    matchLabels:
10      app: dashboard-ui
11  template:
12    metadata:
13      labels:
14        app: dashboard-ui
15    spec:
16      containers:
17        - name: ui
18          image: <your-dockerhub-username>/feedback-ui:latest
19          ports:
20            - containerPort: 80
21---
22apiVersion: v1
23kind: Service
24metadata:
25  name: dashboard-ui
26  namespace: inference
27spec:
28  selector:
29    app: dashboard-ui
30  type: LoadBalancer
31  ports:
32    - port: 80
33      targetPort: 80

1kubectl apply -f ~/Desktop/feedback-extractor/dashboard-ui/ui-deployment.yaml
2kubectl -n inference get svc dashboard-ui

Open the EXTERNAL-IP in your browser.

Step 9: Watch it all come together

Upload a second feedback batch:

1cd ~/Desktop/feedback-extractor
2
3python3 -c "
4import boto3
5from botocore.config import Config
6s3 = boto3.client('s3',
7    endpoint_url='$CIVO_ENDPOINT',
8    aws_access_key_id='$CIVO_ACCESS_KEY',
9    aws_secret_access_key='$CIVO_SECRET_KEY',
10    config=Config(request_checksum_calculation='when_required', response_checksum_validation='when_required')
11)
12with open('feedback.csv', 'rb') as f:
13    s3.put_object(Bucket='feedback-data', Key='raw/feedback2.csv', Body=f.read())
14print('uploaded')
15"

Watch the worker pick it up:

1kubectl -n inference logs -f deployment/inference-worker

Within 30 seconds, it processes the file, and the dashboard updates automatically.

Front-end view

The dashboard gives you a summary of everything our LLM found across all your feedback batches. The stats at the top show total items processed and how many batches have run. Below that, the sentiment bar breaks down the emotional tone across your entire dataset. The themes chart ranks the most frequently mentioned topics by mention count, and the two columns at the bottom surface your top complaints by severity and feature requests by demand score. Everything your users are asking for, ranked and ready to act on.

Summary

What you’ve built is a private feedback intelligence platform. A system that takes raw customer feedback and automatically turns it into structured, actionable insights without any data leaving your infrastructure. Drop a CSV into the Object store and have your Llama 3 model classify the feedback into themes, rank complaints by severity, surface feature requests by demand score, and break down overall sentiment, all running locally on your own GPU node.

The same pattern scales to anything text-heavy: support tickets, app store reviews, NPS responses, sales call transcripts. Swap the model, adjust the prompt, and point it at a different bucket prefix. The GPU node is the only moving cost, scale it to zero between runs, and you're paying for inference time only.

Customer feedback theme extractor on Civo