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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > Gemini API Email Processing and Automation

Gemini API Email Processing and Automation

Author: Venkata Sudhakar

Email remains the dominant communication channel in Indian business. Processing high volumes of customer emails manually is expensive and slow. The Gemini API handles email classification, summarisation, data extraction, and reply drafting in a single pipeline - turning an inbox backlog into structured, actionable data within seconds.

ShopMax India receives over 2,000 customer emails daily across its support, returns, and sales inboxes. The team built a Gemini-powered email processor that classifies each email, extracts key entities, drafts a response where confidence is high, and escalates to a human agent for complex cases. This reduced average email response time from 8 hours to 45 minutes.

The below example shows a complete email processing pipeline that classifies, extracts, and drafts responses using a single Gemini call.

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 process_email(subject: str, body: str, sender: str) -> dict:
    prompt = f"""Analyse this customer email for ShopMax India.
Return ONLY a JSON object with:
- category: one of [order_inquiry, return_request, complaint, product_query, billing_issue, other]
- priority: one of [high, medium, low]
- sentiment: one of [positive, neutral, negative, angry]
- summary: one sentence summary of the issue
- order_id: extracted order ID or null
- draft_reply: a professional reply if straightforward, or null if needs human review
- needs_escalation: true or false
- escalation_reason: reason if needs_escalation is true, else null

From: {sender}
Subject: {subject}
Body: {body}

JSON:
"""

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

# Test email
result = process_email(
    subject="Order not delivered - very frustrated",
    body=("I ordered a Sony WH-1000XM5 headphones (order ORD-58291) on "
          "12th March and was promised delivery by 15th March. It is now "
          "20th March and I have received nothing. No updates either. "
          "This is completely unacceptable. I need this resolved TODAY."),
    sender="ravi.kumar@gmail.com"
)

print(f"Category: {result['category']}")
print(f"Priority: {result['priority']}")
print(f"Sentiment: {result['sentiment']}")
print(f"Order ID: {result['order_id']}")
print(f"Escalate: {result['needs_escalation']}")
print(f"Summary: {result['summary']}")

It gives the following output,

Category: order_inquiry
Priority: high
Sentiment: angry
Order ID: ORD-58291
Escalate: True
Summary: Customer angry about 5-day delayed delivery of Sony WH-1000XM5, order ORD-58291.

The below example shows how to handle the routing logic and send automated responses for low-complexity emails.

def route_and_respond(email_result: dict, email_id: str):
    category = email_result["category"]
    priority = email_result["priority"]
    needs_escalation = email_result["needs_escalation"]

if needs_escalation or priority == "high":
        # Route to human agent queue
        assign_to_human_queue(
            email_id=email_id,
            queue=f"urgent_{category}",
            reason=email_result.get("escalation_reason")
        )
        print(f"Escalated {email_id} to urgent_{category} queue")
    elif email_result.get("draft_reply"):
        # Send automated response
        send_reply(
            email_id=email_id,
            body=email_result["draft_reply"],
            tag="auto_responded"
        )
        print(f"Auto-responded to {email_id}")
    else:
        # Route to standard queue
        assign_to_human_queue(
            email_id=email_id,
            queue=category
        )
        print(f"Routed {email_id} to {category} queue")

# Process a batch from the inbox
emails = fetch_unprocessed_emails(limit=50)
for email in emails:
    processed = process_email(
        subject=email["subject"],
        body=email["body"],
        sender=email["from"]
    )
    route_and_respond(processed, email["id"])

print(f"Processed {len(emails)} emails")

It gives the following output,

Escalated EMAIL-9821 to urgent_order_inquiry queue
Auto-responded to EMAIL-9822
Auto-responded to EMAIL-9823
Routed EMAIL-9824 to product_query queue
Escalated EMAIL-9825 to urgent_complaint queue
Processed 50 emails

The single-call approach - extracting category, priority, sentiment, order IDs, and a draft reply in one Gemini request - minimises latency and API cost per email. For ShopMax India, this means processing 2,000 emails costs roughly the same as 2,000 Gemini API calls, while the value delivered (routing accuracy, 45-minute average response vs 8 hours) is orders of magnitude higher than the infrastructure cost.

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