Building a Smart Grocery Assistant with QuickCommerce API

tools = [
    {
        "type": "function",
        "function": {
            "name": "search_products",
            "description": (
                "Search for a grocery product across all 7 quick commerce platforms "
                "(BlinkIt, Zepto, Swiggy, BigBasket, DMart, JioMart, Minutes). "
                "Returns product name, price, MRP, availability, and image for each platform. "
                "Use this when the user asks about product prices, availability, or wants to compare options."
            ),
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Product search query, e.g. 'Amul Butter 500g' or 'Tata Salt 1kg'",
                    }
                },
                "required": ["query"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "get_delivery_etas",
            "description": (
                "Get estimated delivery times from all 7 quick commerce platforms. "
                "Returns ETA in minutes for each platform. "
                "Use this when the user asks about delivery speed or wants the fastest option."
            ),
            "parameters": {
                "type": "object",
                "properties": {},
                "required": [],
            },
        },
    },
]

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.quickcommerceapi.com/api/v1"
HEADERS = {"X-API-Key": API_KEY}

def search_products(query: str) -> dict:
    resp = requests.get(f"{BASE_URL}/groupsearch", params={"query": query}, headers=HEADERS)
    resp.raise_for_status()
    return resp.json()

def get_delivery_etas(pincode: str = None) -> dict:
    headers = {**HEADERS}
    if pincode:
        headers["x-geolocation-pincode"] = pincode
    resp = requests.get(f"{BASE_URL}/groupeta", headers=headers)
    resp.raise_for_status()
    return resp.json()

def recommend_best_platform(query: str, pincode: str = None) -> dict:
    """Combine price and ETA data to recommend the best platform."""
    search_data = search_products(query)
    eta_data = get_delivery_etas(pincode)

    platforms = []
    for platform, items in search_data.get("results", {}).items():
        if not items or not items[0].get("available"):
            continue

        product = items[0]
        eta_info = eta_data.get("etas", {}).get(platform, {})
        eta_minutes = eta_info.get("etaInMinutes", 999)

        platforms.append({
            "platform": platform,
            "name": product["name"],
            "price": product["price"],
            "mrp": product.get("mrp", product["price"]),
            "savings": product.get("mrp", product["price"]) - product["price"],
            "eta_minutes": eta_minutes,
            "eta_display": eta_info.get("etaDisplay", "N/A"),
            "available": True,
        })

    # Sort by a weighted score: lower is better
    # Price weight: 60%, ETA weight: 40%
    max_price = max(p["price"] for p in platforms) if platforms else 1
    max_eta = max(p["eta_minutes"] for p in platforms) if platforms else 1

    for p in platforms:
        price_score = p["price"] / max_price
        eta_score = p["eta_minutes"] / max_eta
        p["score"] = (price_score * 0.6) + (eta_score * 0.4)

    platforms.sort(key=lambda x: x["score"])

    return {
        "query": query,
        "recommendation": platforms[0] if platforms else None,
        "cheapest": min(platforms, key=lambda x: x["price"]) if platforms else None,
        "fastest": min(platforms, key=lambda x: x["eta_minutes"]) if platforms else None,
        "all_options": platforms,
    }

# Example usage
result = recommend_best_platform("Tata Salt 1kg", pincode="400001")
print(f"Best overall: {result['recommendation']['platform']}")
print(f"Cheapest: {result['cheapest']['platform']} at Rs {result['cheapest']['price']}")
print(f"Fastest: {result['fastest']['platform']} in {result['fastest']['eta_display']}")

import json
from openai import OpenAI

client = OpenAI()
SYSTEM_PROMPT = """You are a helpful Indian grocery shopping assistant. You help users find
the best prices and fastest delivery across 7 quick commerce platforms:
BlinkIt, Zepto, Swiggy Instamart, BigBasket, DMart Ready, JioMart, and Minutes.

When users ask about products, use the search_products tool to find prices.
When they ask about delivery speed, use the get_delivery_etas tool.
When they want a recommendation, use both tools.

Always mention prices in INR (Rs). Be concise and helpful.
Highlight the best option clearly and explain trade-offs when relevant."""

def handle_tool_call(tool_call):
    """Execute the API call and return results."""
    name = tool_call.function.name
    args = json.loads(tool_call.function.arguments)

    if name == "search_products":
        return json.dumps(search_products(args["query"]))
    elif name == "get_delivery_etas":
        return json.dumps(get_delivery_etas())
    return json.dumps({"error": "Unknown tool"})

def chat(user_message: str, conversation: list) -> str:
    """Process a user message and return the assistant's response."""
    conversation.append({"role": "user", "content": user_message})

    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "system", "content": SYSTEM_PROMPT}] + conversation,
        tools=tools,  # from tools_definition.py
    )

    message = response.choices[0].message

    # Handle tool calls if the model wants to use a tool
    while message.tool_calls:
        conversation.append(message)
        for tool_call in message.tool_calls:
            result = handle_tool_call(tool_call)
            conversation.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result,
            })

        response = client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "system", "content": SYSTEM_PROMPT}] + conversation,
            tools=tools,
        )
        message = response.choices[0].message

    conversation.append(message)
    return message.content

# Run the chatbot
if __name__ == "__main__":
    conversation = []
    print("Grocery Assistant: Hi! I can help you find the best prices")
    print("and fastest delivery across 7 quick commerce apps. Ask me anything!\n")

    while True:
        user_input = input("You: ").strip()
        if not user_input or user_input.lower() in ("quit", "exit", "bye"):
            print("Grocery Assistant: Bye! Happy shopping!")
            break
        response = chat(user_input, conversation)
        print(f"Grocery Assistant: {response}\n")