Generative AI for Data Workflows

Prompt Engineering, RAG, and SQL Generation

**Generative AI** is transforming how analysts interact with data. Instead of writing SQL manually, you can **prompt** an LLM to generate it. Instead of searching through documentation, **RAG (Retrieval-Augmented Generation)** feeds relevant context to the model automatically. For **Walmart**, this means a supply chain manager can ask "What's the average transit time for perishables in Q4?" and get instant SQL + results.

In this chapter, we explore **Prompt Engineering** best practices, the **RAG** architecture, and how to build a **Text-to-SQL** pipeline that turns natural language into database queries.

Prompt Engineering: The Art of Asking

The quality of an LLM's output depends almost entirely on the quality of the **prompt**. A vague prompt produces vague results. **Prompt Engineering** is the practice of crafting precise, structured instructions. For **Netflix**, this means the difference between getting "Recommend some shows" vs "Recommend 5 sci-fi shows released after 2020 with rating > 8.5, focusing on strong female leads."

PythonRuns entirely in your browser — nothing is sent to a server.

# Prompt Engineering: Template System
class PromptEngineer:
    def __init__(self, role, context):
        self.role = role
        self.context = context

    def build_prompt(self, user_query, constraints=None):
        prompt = "SYSTEM: You are a {0}.\n".format(self.role)
        prompt += "CONTEXT: {0}\n".format(self.context)
        prompt += "USER QUERY: {0}\n".format(user_query)
        
        if constraints:
            prompt += "CONSTRAINTS:\n"
            for i, c in enumerate(constraints):
                prompt += " {0}. {1}\n".format(i + 1, c)
        
        print("ENGINEERED PROMPT:")
        print("=" * 50)
        print(prompt)
        
        # Simulate LLM response quality
        quality = "HIGH" if constraints and len(constraints) >= 2 else "LOW"
        print("EXPECTED OUTPUT QUALITY: {0}".format(quality))

# Scenario: Netflix content recommendation prompt
engineer = PromptEngineer(
    role="Netflix Content Analyst",
    context="User prefers sci-fi, has watched Stranger Things and Black Mirror"
)
engineer.build_prompt(
    user_query="Recommend shows for this user",
    constraints=["Only shows released after 2020", "Rating > 8.0", "Available in Hindi"]
)

# Prompt Engineering: Template System
class PromptEngineer:
    def __init__(self, role, context):
        self.role = role
        self.context = context

    def build_prompt(self, user_query, constraints=None):
        prompt = "SYSTEM: You are a {0}.\n".format(self.role)
        prompt += "CONTEXT: {0}\n".format(self.context)
        prompt += "USER QUERY: {0}\n".format(user_query)
        
        if constraints:
            prompt += "CONSTRAINTS:\n"
            for i, c in enumerate(constraints):
                prompt += " {0}. {1}\n".format(i + 1, c)
        
        print("ENGINEERED PROMPT:")
        print("=" * 50)
        print(prompt)
        
        # Simulate LLM response quality
        quality = "HIGH" if constraints and len(constraints) >= 2 else "LOW"
        print("EXPECTED OUTPUT QUALITY: {0}".format(quality))

# Scenario: Netflix content recommendation prompt
engineer = PromptEngineer(
    role="Netflix Content Analyst",
    context="User prefers sci-fi, has watched Stranger Things and Black Mirror"
)
engineer.build_prompt(
    user_query="Recommend shows for this user",
    constraints=["Only shows released after 2020", "Rating > 8.0", "Available in Hindi"]
)

RAG: Retrieval-Augmented Generation

**RAG** solves the LLM hallucination problem by grounding the model's responses in real data. Instead of relying on the model's training data (which can be outdated), RAG retrieves relevant documents from your database and feeds them as context to the prompt. For **Walmart**, this means the LLM answers supply chain questions using actual inventory data, not guesses.

PythonRuns entirely in your browser — nothing is sent to a server.

# Walmart Supply Chain: RAG Pipeline Simulation
class RAGPipeline:
    def __init__(self, knowledge_base):
        self.kb = knowledge_base # Simulated vector store

    def retrieve(self, query, top_k=2):
        print("RAG STEP 1 - RETRIEVE:")
        print(" Query: '{0}'".format(query))
        # Simulate semantic search (finding most relevant docs)
        scored = []
        query_words = set(query.lower().split())
        for doc in self.kb:
            overlap = len(query_words.intersection(set(doc.lower().split())))
            scored.append((overlap, doc))
        scored.sort(reverse=True)
        
        retrieved = [doc for _, doc in scored[:top_k]]
        for i, doc in enumerate(retrieved):
            print(" - Doc {0}: '{1}'".format(i + 1, doc))
        return retrieved

    def generate(self, query, retrieved_docs):
        print("\nRAG STEP 2 - GENERATE:")
        context = " | ".join(retrieved_docs)
        print(" Context fed to LLM: {0}".format(context))
        print(" LLM Answer: Based on retrieved data, the answer is grounded in facts.")

# Scenario: Walmart supply chain Q&A
kb = [
    "Average transit time for perishables in Q4 2025 was 18.5 hours",
    "Warehouse capacity in APAC reached 92% in December",
    "Non-perishable goods have a 3-day average shelf restock cycle",
    "Cold chain compliance rate was 97.3% across all regions"
]
rag = RAGPipeline(knowledge_base=kb)
docs = rag.retrieve("What is the transit time for perishables?")
rag.generate("Transit time for perishables?", docs)

# Walmart Supply Chain: RAG Pipeline Simulation
class RAGPipeline:
    def __init__(self, knowledge_base):
        self.kb = knowledge_base # Simulated vector store

    def retrieve(self, query, top_k=2):
        print("RAG STEP 1 - RETRIEVE:")
        print(" Query: '{0}'".format(query))
        # Simulate semantic search (finding most relevant docs)
        scored = []
        query_words = set(query.lower().split())
        for doc in self.kb:
            overlap = len(query_words.intersection(set(doc.lower().split())))
            scored.append((overlap, doc))
        scored.sort(reverse=True)
        
        retrieved = [doc for _, doc in scored[:top_k]]
        for i, doc in enumerate(retrieved):
            print(" - Doc {0}: '{1}'".format(i + 1, doc))
        return retrieved

    def generate(self, query, retrieved_docs):
        print("\nRAG STEP 2 - GENERATE:")
        context = " | ".join(retrieved_docs)
        print(" Context fed to LLM: {0}".format(context))
        print(" LLM Answer: Based on retrieved data, the answer is grounded in facts.")

# Scenario: Walmart supply chain Q&A
kb = [
    "Average transit time for perishables in Q4 2025 was 18.5 hours",
    "Warehouse capacity in APAC reached 92% in December",
    "Non-perishable goods have a 3-day average shelf restock cycle",
    "Cold chain compliance rate was 97.3% across all regions"
]
rag = RAGPipeline(knowledge_base=kb)
docs = rag.retrieve("What is the transit time for perishables?")
rag.generate("Transit time for perishables?", docs)

Text-to-SQL: Natural Language to Database Queries

**Text-to-SQL** allows non-technical users to query databases in plain English. For **Visa**, a compliance officer can ask "Show me all transactions over $10,000 from foreign merchants in the last 30 days" and get a ready-to-run SQL query. This democratizes data access across the organization.

PythonRuns entirely in your browser — nothing is sent to a server.

# Visa Analytics: Text-to-SQL Generator
class TextToSQL:
    def __init__(self, schema):
        self.schema = schema # Available tables and columns

    def generate_sql(self, natural_query):
        print("TEXT-TO-SQL ENGINE:")
        print(" Input : '{0}'".format(natural_query))
        print(" Schema: {0}".format(self.schema))
        
        # Rule-based SQL generation (simulating LLM)
        sql = "SELECT "
        query_lower = natural_query.lower()
        
        if "total" in query_lower or "sum" in query_lower:
            sql += "merchant, SUM(amount) as total"
        elif "count" in query_lower:
            sql += "merchant, COUNT(*) as tx_count"
        else:
            sql += "*"
        
        sql += " FROM transactions WHERE 1=1"
        
        if "foreign" in query_lower:
            sql += " AND is_foreign = TRUE"
        if "$" in natural_query:
            # Extract amount
            import re
            amounts = re.findall(r"\$(\d+)", natural_query)
            if amounts:
                sql += " AND amount > {0}".format(amounts[0])
        
        sql += " GROUP BY merchant ORDER BY total DESC;"
        
        print("\nGENERATED SQL:")
        print(" {0}".format(sql))

# Scenario: Visa compliance query
schema = {"transactions": ["id", "amount", "merchant", "is_foreign", "date"]}
engine = TextToSQL(schema)
engine.generate_sql("Show total spending by foreign merchants over $5000")

# Visa Analytics: Text-to-SQL Generator
class TextToSQL:
    def __init__(self, schema):
        self.schema = schema # Available tables and columns

    def generate_sql(self, natural_query):
        print("TEXT-TO-SQL ENGINE:")
        print(" Input : '{0}'".format(natural_query))
        print(" Schema: {0}".format(self.schema))
        
        # Rule-based SQL generation (simulating LLM)
        sql = "SELECT "
        query_lower = natural_query.lower()
        
        if "total" in query_lower or "sum" in query_lower:
            sql += "merchant, SUM(amount) as total"
        elif "count" in query_lower:
            sql += "merchant, COUNT(*) as tx_count"
        else:
            sql += "*"
        
        sql += " FROM transactions WHERE 1=1"
        
        if "foreign" in query_lower:
            sql += " AND is_foreign = TRUE"
        if "$" in natural_query:
            # Extract amount
            import re
            amounts = re.findall(r"\$(\d+)", natural_query)
            if amounts:
                sql += " AND amount > {0}".format(amounts[0])
        
        sql += " GROUP BY merchant ORDER BY total DESC;"
        
        print("\nGENERATED SQL:")
        print(" {0}".format(sql))

# Scenario: Visa compliance query
schema = {"transactions": ["id", "amount", "merchant", "is_foreign", "date"]}
engine = TextToSQL(schema)
engine.generate_sql("Show total spending by foreign merchants over $5000")

Practice Questions

Question 1

What problem does RAG solve that standard LLMs cannot?

It makes the model faster
It grounds the model's responses in real, retrieved data, preventing hallucination and ensuring answers are based on current facts
It replaces the need for a database
It only works with GPT-4

Question 2

Why is Prompt Engineering considered a critical skill for data analysts?

Because it reduces the cost of electricity
Because the precision and structure of the prompt directly determines the quality and relevance of the LLM's output
Because it replaces Python
Because it only works in English