Llama 4 for Local Business Automation: Free Setup via Groq

What Is Llama 4?

• Llama 4 Scout (17B active parameters): Fast, cost-efficient, excellent for structured tasks like review replies and SMS drafting
• Llama 4 Maverick (17B active parameters, multimodal): Handles images as well as text — useful for generating captions from product photos

What Is Groq and Why Is It Free?

• Llama 4 Scout: 30 requests per minute, 6,000 tokens per minute, 14,400 requests per day
• Llama 4 Maverick: 30 requests per minute, 6,000 tokens per minute, 14,400 requests per day
• Rate limits reset every minute and every day

Step-by-Step Setup

Step 1: Get Your Groq API Key

1. Go to console.groq.com
2. Sign up with your Google account or email
3. Navigate to API Keys in the left sidebar
4. Click Create API Key, give it a name (e.g., "My Business Bot"), and copy the key
5. Store it somewhere safe — Groq only shows it once

Step 2: Install the Groq Python Library

# Make sure you have Python 3.8+ installed
python --version

# Install the Groq SDK
pip install groq

# Optional: install python-dotenv to manage your API key securely
pip install python-dotenv

echo "GROQ_API_KEY=gsk_your-key-here" > .env

Step 3: Make Your First Call

import os
from groq import Groq
from dotenv import load_dotenv

load_dotenv()

client = Groq(api_key=os.environ.get("GROQ_API_KEY"))

def ask_llama(system_prompt: str, user_message: str, model: str = "meta-llama/llama-4-scout-17b-16e-instruct") -> str:
    """
    Simple wrapper for Groq API calls.
    Default model: Llama 4 Scout (fast, free tier)
    """
    response = client.chat.completions.create(
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_message}
        ],
        model=model,
        temperature=0.7,
        max_tokens=300,
    )
    return response.choices[0].message.content

# Test it
result = ask_llama(
    system_prompt="You are the friendly owner of Paws & Clippers pet grooming salon.",
    user_message="Write a reply to this Google review: 'Rocky came back smelling amazing and looking so fluffy! Best groomer in town!'"
)
print(result)

4 Automation Scripts for Local Businesses

Automation 1: Auto-Reply to Google Reviews

import os
from groq import Groq
from dotenv import load_dotenv

load_dotenv()
client = Groq(api_key=os.environ.get("GROQ_API_KEY"))

BUSINESS_NAME = "The Daily Grind Cafe"
BUSINESS_TYPE = "coffee shop"

def generate_review_reply(review: dict) -> str:
    star_rating = review.get("rating", 5)
    tone_guidance = (
        "Be warm and grateful." if star_rating >= 4
        else "Acknowledge the issue, apologize sincerely, and offer to make it right."
    )

    response = client.chat.completions.create(
        messages=[
            {
                "role": "system",
                "content": (
                    f"You are the owner of {BUSINESS_NAME}, a {BUSINESS_TYPE}. "
                    f"Write a Google review reply. {tone_guidance} "
                    "Keep it under 100 words. Sound human and specific to the review."
                )
            },
            {"role": "user", "content": f"Customer review ({star_rating} stars): {review['text']}"}
        ],
        model="meta-llama/llama-4-scout-17b-16e-instruct",
        temperature=0.7,
        max_tokens=150,
    )
    return response.choices[0].message.content

# Example batch
reviews = [
    {"rating": 5, "text": "Perfect oat milk latte every single time. Staff remembers my order!"},
    {"rating": 2, "text": "Waited 20 minutes and my drink was cold. Very disappointed."},
    {"rating": 4, "text": "Great coffee but seating is limited on weekends."},
]

for review in reviews:
    reply = generate_review_reply(review)
    print(f"[{review['rating']} stars] {review['text'][:50]}...")
    print(f"Reply: {reply}\n")

Automation 2: Weekly Social Post Schedule Generator

import os
import json
from groq import Groq
from dotenv import load_dotenv

load_dotenv()
client = Groq(api_key=os.environ.get("GROQ_API_KEY"))

def generate_weekly_schedule(business_info: dict) -> list:
    """
    Generates 5 social media posts for the week (Mon-Fri).
    Returns a list of dicts with day, caption, and hashtags.
    """
    prompt = f"""
    Business: {business_info['name']} ({business_info['type']})
    Current promotion: {business_info.get('promo', 'None')}
    Brand voice: {business_info.get('voice', 'friendly and professional')}
    
    Generate exactly 5 Instagram captions for Monday through Friday.
    Mix content types: product highlight, behind-the-scenes, customer tip, promotion, community.
    Each caption should be 50-100 words with 4-6 relevant hashtags.
    
    Return as valid JSON array: [{{"day": "Monday", "caption": "...", "hashtags": ["...", "..."]}}]
    """

    response = client.chat.completions.create(
        messages=[
            {"role": "system", "content": "You are a social media manager for local businesses. Always return valid JSON."},
            {"role": "user", "content": prompt}
        ],
        model="meta-llama/llama-4-scout-17b-16e-instruct",
        temperature=0.8,
        max_tokens=1200,
        response_format={"type": "json_object"}
    )

    raw = response.choices[0].message.content
    data = json.loads(raw)
    return data.get("posts", data)  # handle both {"posts": [...]} and [...]

# Example
business = {
    "name": "Bloom Beauty Studio",
    "type": "hair salon",
    "promo": "15% off balayage services throughout June",
    "voice": "warm, aspirational, beauty-focused"
}

schedule = generate_weekly_schedule(business)
for post in schedule:
    print(f"\n{post.get('day', 'Day')}:")
    print(post.get('caption', ''))
    print("Hashtags:", " ".join(f"#{h}" for h in post.get('hashtags', [])))

Automation 3: FAQ Chatbot from a Text File

import os
from groq import Groq
from dotenv import load_dotenv

load_dotenv()
client = Groq(api_key=os.environ.get("GROQ_API_KEY"))

def load_faq_document(filepath: str) -> str:
    with open(filepath, "r", encoding="utf-8") as f:
        return f.read()

def answer_customer_question(question: str, faq_content: str, business_name: str) -> str:
    response = client.chat.completions.create(
        messages=[
            {
                "role": "system",
                "content": (
                    f"You are a helpful assistant for {business_name}. "
                    "Answer customer questions using ONLY the information in the FAQ document below. "
                    "If the answer is not in the document, say 'I don't have that information — please call us directly.' "
                    "Be friendly and concise.\n\n"
                    f"FAQ DOCUMENT:\n{faq_content}"
                )
            },
            {"role": "user", "content": question}
        ],
        model="meta-llama/llama-4-scout-17b-16e-instruct",
        temperature=0.3,  # Lower temp for factual accuracy
        max_tokens=200,
    )
    return response.choices[0].message.content

# Create a sample FAQ file (faq.txt) with your business info, then:
# faq_content = load_faq_document("faq.txt")

# For demo purposes:
sample_faq = """
Hours: Monday-Saturday 9am-7pm, Sunday 10am-5pm
Parking: Free parking behind the building on Oak Street
Booking: Online at our website or call (555) 123-4567
Cancellation policy: 24-hour notice required to avoid a $25 fee
Services: Haircut ($45), Color ($120+), Balayage ($180+), Blow-dry ($35)
Products: We use and sell Kevin Murphy and Olaplex products
"""

questions = [
    "Do you have parking?",
    "How much does a balayage cost?",
    "What's your cancellation policy?",
    "Do you do nail services?"
]

for q in questions:
    answer = answer_customer_question(q, sample_faq, "Bloom Beauty Studio")
    print(f"Q: {q}")
    print(f"A: {answer}\n")

Automation 4: Appointment Reminder Email Drafts

import os
from groq import Groq
from datetime import datetime, timedelta
from dotenv import load_dotenv

load_dotenv()
client = Groq(api_key=os.environ.get("GROQ_API_KEY"))

def draft_reminder_email(appointment: dict) -> dict:
    """
    Generates a personalized appointment reminder email.
    Returns dict with subject and body.
    """
    appt_time = appointment['datetime'].strftime("%A, %B %d at %I:%M %p")

    prompt = f"""
    Write an appointment reminder email for:
    - Client name: {appointment['client_name']}
    - Service: {appointment['service']}
    - Staff member: {appointment['staff']}
    - Date/time: {appt_time}
    - Business: {appointment['business_name']}
    - Business address: {appointment['address']}
    
    Include: greeting, appointment details, any prep instructions for {appointment['service']},
    cancellation policy (24hr notice), and a warm sign-off.
    Keep total length under 200 words.
    
    Return as JSON: {{"subject": "...", "body": "..."}}
    """

    response = client.chat.completions.create(
        messages=[
            {"role": "system", "content": "You are an email assistant for a local service business. Return valid JSON only."},
            {"role": "user", "content": prompt}
        ],
        model="meta-llama/llama-4-scout-17b-16e-instruct",
        temperature=0.6,
        max_tokens=400,
        response_format={"type": "json_object"}
    )

    import json
    return json.loads(response.choices[0].message.content)

# Example
appointment = {
    "client_name": "Emma Thompson",
    "service": "Balayage + Toner",
    "staff": "Jessica",
    "datetime": datetime.now() + timedelta(days=1, hours=3),
    "business_name": "Bloom Beauty Studio",
    "address": "142 Maple Ave, Portland, OR 97201"
}

email = draft_reminder_email(appointment)
print(f"Subject: {email['subject']}")
print(f"\nBody:\n{email['body']}")

Free vs Paid Tier Comparison

• 50 review replies/month → easily within limits
• 20 social posts/week → easily within limits
• 200 FAQ chatbot queries/day → within daily limits

When Free Isn't Enough

Real-World Performance: What to Expect

• Short review reply (150 tokens output): ~0.4 seconds
• Social caption with hashtags (200 tokens): ~0.5 seconds
• FAQ answer (100 tokens): ~0.25 seconds
• Full appointment email (350 tokens): ~0.9 seconds

FAQ

Related Articles

• OpenRouter Guide: Access 100+ AI Models for Local Business Automation
• GPT-4o Mini vs Groq Llama: Cost Comparison for Small Business 2026
• Ollama: Run a Local LLM for Free on Your Own Machine
• Best Free OpenRouter Models for Business Automation
• Mistral AI for Small Business: Practical Use Cases in 2026