	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > Gemini API for Sentiment Analysis at Scale

Gemini API for Sentiment Analysis at Scale

Author: Venkata Sudhakar

Sentiment analysis with LLMs is fundamentally different from traditional NLP approaches. The Gemini API understands context, sarcasm, mixed sentiment, and domain-specific language without any training data. It can identify not just whether a review is positive or negative, but which specific aspects of a product or service the customer is praising or criticising.

ShopMax India analyses customer reviews across its website and app - over 5,000 new reviews per day. The product team uses Gemini to extract aspect-level sentiment: delivery speed, product quality, packaging, customer service, and value for money are scored independently for each review. This feeds directly into supplier scorecards and product listing improvements.

The below example shows aspect-level sentiment analysis on a customer review using Gemini with structured JSON output.

import vertexai
from vertexai.generative_models import GenerativeModel
import json

vertexai.init(project="shopmax-india", location="asia-south1")
model = GenerativeModel("gemini-2.0-flash")

def analyse_review(review_text: str, product_category: str) -> dict:
    prompt = f"""Analyse this {product_category} product review for ShopMax India.
Return ONLY a JSON object with:
- overall_sentiment: positive / negative / mixed / neutral
- overall_score: float -1.0 to 1.0
- aspects: object with these keys (score -1.0 to 1.0, or null if not mentioned):
    - product_quality
    - delivery_speed
    - packaging
    - value_for_money
    - customer_service
- emotions: list from [happy, frustrated, disappointed, satisfied, angry, surprised]
- key_phrases: list of 3-5 phrases that best summarise the review
- would_recommend: true / false / null (if unclear)

Review: {review_text}

JSON:
"""

response = model.generate_content(
        prompt,
        generation_config={"temperature": 0.1, "response_mime_type": "application/json"}
    )
    return json.loads(response.text)

review = """
Ordered the Sony WH-1000XM5 headphones. Delivered in just one day which was
amazing! The packaging was premium and the product is excellent - noise
cancellation is superb. However Rs 34,990 feels steep compared to Amazon.
Customer care was helpful when I had a query about warranty. Overall happy
but wish the price was more competitive.
"""

result = analyse_review(review, "electronics")
print(f"Overall: {result['overall_sentiment']} (score: {result['overall_score']:.2f})")
print(f"Emotions: {result['emotions']}")
print(f"Recommend: {result['would_recommend']}")
print("Aspects:")
for aspect, score in result["aspects"].items():
    if score is not None:
        label = "positive" if score > 0.2 else ("negative" if score < -0.2 else "neutral")
        print(f"  {aspect}: {score:.2f} ({label})")

It gives the following output,

Overall: mixed (score: 0.52)
Emotions: ['happy', 'satisfied']
Recommend: True
Aspects:
  product_quality: 0.90 (positive)
  delivery_speed: 0.95 (positive)
  packaging: 0.80 (positive)
  value_for_money: -0.40 (negative)
  customer_service: 0.70 (positive)

The below example shows how to aggregate sentiment across a batch of reviews to generate a product scorecard.

def generate_product_scorecard(reviews: list, product_id: str) -> dict:
    all_aspects = {
        "product_quality": [],
        "delivery_speed": [],
        "packaging": [],
        "value_for_money": [],
        "customer_service": []
    }
    overall_scores = []
    recommend_count = 0

for review_text in reviews:
        result = analyse_review(review_text, "electronics")
        overall_scores.append(result["overall_score"])
        if result["would_recommend"]:
            recommend_count += 1
        for aspect, score in result["aspects"].items():
            if score is not None:
                all_aspects[aspect].append(score)

avg = lambda lst: round(sum(lst) / len(lst), 2) if lst else None

return {
        "product_id": product_id,
        "review_count": len(reviews),
        "overall_sentiment_avg": avg(overall_scores),
        "recommend_pct": round(recommend_count / len(reviews) * 100),
        "aspect_scores": {k: avg(v) for k, v in all_aspects.items()}
    }

# Simulate scorecard for product SKU-9821
scorecard = generate_product_scorecard([review] * 3, "SKU-9821")
print(f"Product: {scorecard['product_id']}")
print(f"Reviews: {scorecard['review_count']}, Recommend: {scorecard['recommend_pct']}%")
print(f"Aspect scores: {scorecard['aspect_scores']}")

It gives the following output,

Product: SKU-9821
Reviews: 3, Recommend: 100%
Aspect scores: {'product_quality': 0.9, 'delivery_speed': 0.95,
                'packaging': 0.8, 'value_for_money': -0.4,
                'customer_service': 0.7}

Aspect-level sentiment gives ShopMax India actionable signals that star ratings alone cannot provide. A product with a 4-star average might have excellent quality scores but consistently negative value_for_money sentiment - a clear signal to review pricing strategy rather than supplier quality. This granularity is what makes Gemini-powered sentiment analysis more valuable than traditional positive/negative classification for merchandising decisions.

Send your comments, suggestions or queries regarding this site to [email protected].