pip install --upgrade pandas openai minds-sdk

websales_sales.product_id  → websales_products.product_id
websales_sales.order_id    → websales_orders.order_id
websales_sales.customer_id → websales_customers.customer_id

import os, re, json
import pandas as pd
from openai import OpenAI
from minds.client import Client

BASE_URL      = "https://mdb.ai/api/v1"
MINDS_API_KEY = "CREATE_YOUR_KEY" # "CREATE_YOUR_KEY at https://mindsdb.com/contact"
MIND_NAME     = "web_sales_demo_mind"
DATA_SOURCES  = [{
    'name': 'postgres_web_sales_datasource',
    'tables': [
        'websales_orders',
        'websales_sales',
        'websales_products',
        'websales_customers',
    ]
}]

client = Client(api_key=MINDS_API_KEY, base_url=BASE_URL)

PROMPT_TEMPLATE = """
# ROLE AND TASK

You are a precise data analyst with access to a SQL execution tool named **sql_db_query**.
You MUST (a) generate SQL, (b) EXECUTE it via sql_db_query, and (c) based ONLY on the returned rows,
return the answer in markdown format and always create a chart whenever possible.
Generate URL-encoded charts via quickchart.io like this:

https://quickchart.io/chart?c=%7Btype%3A%27line%27%2Cdata%3A%7Blabels%3A%5B%27Jan%27%2C%27Feb%27%2C%27Mar%27%2C%27Apr%27%2C%27May%27%2C%27Jun%27%5D%2Cdatasets%3A%5B%7Blabel%3A%27Sales%27%2Cdata%3A%5B65%2C59%2C80%2C81%2C56%2C95%5D%2CborderColor%3A%27rgb(75%2C192%2C192)%27%7D%5D%7D%7D
https://quickchart.io/chart?c=%7Btype%3A%27pie%27%2Cdata%3A%7Blabels%3A%5B%27CompanyA%27%2C%27CompanyB%27%2C%27CompanyC%27%2C%27Others%27%5D%2Cdatasets%3A%5B%7Bdata%3A%5B35%2C25%2C20%2C20%5D%2CbackgroundColor%3A%5B%27%23FF6384%27%2C%27%2336A2EB%27%2C%27%23FFCE56%27%2C%27%234BC0C0%27%5D%7D%5D%7D%7D
https://quickchart.io/chart?c=%7Btype%3A%27bar%27%2Cdata%3A%7Blabels%3A%5B%27North%27%2C%27South%27%2C%27East%27%2C%27West%27%5D%2Cdatasets%3A%5B%7Blabel%3A%27Revenue%27%2Cdata%3A%5B120%2C190%2C300%2C250%5D%7D%5D%7D%7D

# SCHEMA (use schema-qualified names ONLY; do NOT include datasource name)
- postgres_web_sales_datasource.websales_orders     (order_id, order_date, ship_date, ship_mode, ...)
- postgres_web_sales_datasource.websales_sales      (order_id, product_id, customer_id, sales, quantity, discount, profit)
- postgres_web_sales_datasource.websales_products   (product_id, category, sub_category, product_name)
- postgres_web_sales_datasource.websales_customers  (customer_id, customer_name, segment, country, city, state, postal_code, region)

# JOINS

- websales_sales.product_id  -> websales_products.product_id
- websales_sales.order_id    -> websales_orders.order_id
- websales_sales.customer_id -> websales_customers.customer_id

# GUIDELINES

When answering questions, follow these guidelines:
    For questions about database tables and their contents:
    - Use the sql_db_query to query the tables directly
    - You can join tables if needed to get comprehensive information
    - **Important Rule for SQL Queries:** If you formulate an SQL query as part of answering a user's question,
    you *must* then use the `sql_db_query` tool to execute that query and get its results.
    The SQL query string itself is NOT the final answer to the user unless the user has specifically asked for the query.
    Your final AI response should be based on the *results* obtained from executing the query.
    For factual questions, ALWAYS use the available tools to look up information rather than relying on your internal knowledge.
"""

mind = client.minds.create(
    name=MIND_NAME,
    datasources=DATA_SOURCES,
    parameters={
        'system_prompt': PROMPT_TEMPLATE
    },
    replace=True
)

oa = OpenAI(api_key=MINDS_API_KEY, base_url=BASE_URL)

def collect_response(question):
    """
    Collect the final response from the Mind.
    """
    r = oa.chat.completions.create(
        model=MIND_NAME,
        messages=[{"role": "user", "content": question}],
        temperature=0.1
    )
    full_response = r.choices[0].message.content or ""

    return full_response

def stream_and_collect_response(question):
    """
    Stream the LLM response, print reasoning trace, but only return the final answer
    """
    print(f"\n=== QUESTION ===\n{question}\n")
    print("=== LLM REASONING TRACE START ===\n")
    
    completion = oa.chat.completions.create(
        model=MIND_NAME,
        messages=[{"role": "user", "content": question}],
        temperature=0.1,
        stream=True
    )
    
    full_response = ""
    
    try:
        for chunk in completion:
            if hasattr(chunk, 'choices') and chunk.choices:
                choice = chunk.choices[0]
                if hasattr(choice, 'delta') and choice.delta:
                    content = getattr(choice.delta, 'content', None)
                    if content is not None:
                        print(content, end='', flush=True)
                        full_response += content
    except Exception as e:
        print(f"\nStreaming error: {e}")
        # Fallback to non-streaming
        r = oa.chat.completions.create(
            model=MIND_NAME,
            messages=[{"role": "user", "content": question}],
            temperature=0.1
        )
        full_response = r.choices[0].message.content or ""
        print(full_response)
    
    print("\n")
    print("=== LLM REASONING TRACE END ===\n")
    
    # Extract only the final answer (everything after "I finished executing the SQL query")
    final_answer = extract_final_answer(full_response)
    
    return final_answer

def extract_final_answer(full_response):
    """
    Extract the final answer from the full response using the end-of-reasoning marker
    """
    end_marker = "I finished executing the SQL query"
    
    # Find the position of the end-of-reasoning marker
    marker_pos = full_response.find(end_marker)
    
    if marker_pos != -1:
        # Extract everything after the marker
        final_answer = full_response[marker_pos + len(end_marker):].strip()
        return final_answer
    else:
        # Fallback: if marker not found, return the full response
        return full_response.strip()

def render_markdown(response):
    """
    Render the markdown content generated by the Mind.
    """
    try:
        from IPython.display import Markdown, display
        display(Markdown(response))
    except ImportError:
        # Fallback for non-Jupyter environments: simply print the markdown string
        print(response)

def ask(question):
    """
    Ask a question to the mind, show reasoning trace, and return DataFrame
    """
    response = stream_and_collect_response(question)
    #response = collect_response(question)
    render_markdown(response)

ask("What's the total sales revenue by product category?")

=== QUESTION ===
What's the total sales revenue by product category?

=== LLM REASONING TRACE START ===

I will now generate the SQL query to answer your question.Here is the generated SQL query along with its execution result:
Query executed: SELECT wp.category, SUM(s.sales) as total_sales_revenue 
FROM postgres_web_sales_datasource.websales_sales s 
JOIN postgres_web_sales_datasource.websales_products wp ON s.product_id = wp.product_id 
GROUP BY wp.category

Results: 3 rows x 2 columns

category                total_sales_revenue
Hybrid Work Essentials 1525521.9           
  Smart Office Devices 4288440.0           
     Connected Devices 1288424.8           Here are the total sales revenues by product category:

- **Smart Office Devices:** $4,288,440.00
- **Hybrid Work Essentials:** $1,525,521.90
- **Connected Devices:** $1,288,424.80

Here is a bar chart showing the sales revenue by category:

![Sales Revenue by Category](https://quickchart.io/chart?c=%7Btype%3A%27bar%27%2Cdata%3A%7Blabels%3A%5B%27Smart%20Office%20Devices%27%2C%27Hybrid%20Work%20Essentials%27%2C%27Connected%20Devices%27%5D%2Cdatasets%3A%5B%7Blabel%3A%27Total%20Sales%20Revenue%27%2Cdata%3A%5B4288440.0%2C1525521.9%2C1288424.8%5D%7D%5D%7D%7D)

=== LLM REASONING TRACE 

ask("What is the total sales revenue for each shipping mode, and which delivery option generates the most revenue?")

=== QUESTION ===
What is the total sales revenue for each shipping mode, and which delivery option generates the most revenue?

=== LLM REASONING TRACE START ===

I will now generate the SQL query to answer your question.Here is the generated SQL query along with its execution result:
Query executed: SELECT wo.ship_mode, SUM(ws.sales) AS total_revenue
FROM postgres_web_sales_datasource.websales_orders wo
JOIN postgres_web_sales_datasource.websales_sales ws ON wo.order_id = ws.order_id
GROUP BY wo.ship_mode
ORDER BY total_revenue DESC

Results: 3 rows x 2 columns

ship_mode         total_revenue
 Premium Express 2407209.8     
    Eco Delivery 2397529.8     
Instant Delivery 2297646.0     Here is the total sales revenue generated by each shipping mode:

| Shipping Mode       | Total Revenue  |
|---------------------|----------------|
| Premium Express     | $2,407,209.80  |
| Eco Delivery        | $2,397,529.80  |
| Instant Delivery    | $2,297,646.00  |

The shipping mode that generates the most revenue is **Premium Express** with a total revenue of $2,407,209.80.

![Revenue by Shipping Mode](https://quickchart.io/chart?c=%7Btype%3A%27bar%27%2Cdata%3A%7Blabels%3A%5B%27Premium%20Express%27%2C%27Eco%20Delivery%27%2C%27Instant%20Delivery%27%5D%2Cdatasets%3A%5B%7Blabel%3A%27Total%20Revenue%27%2Cdata%3A%5B2407209.8%2C2397529.8%2C2297646.0%5D%2CbackgroundColor%3A%5B%27%234BC0C0%27%2C%27%23FFCE56%27%2C%27%23FF6384%27%5D%7D%5D%7D%7D)

=== LLM REASONING TRACE END

=== QUESTION ===
How does total sales revenue compare across different customer segments (Startup vs Enterprise vs others)?

=== LLM REASONING TRACE START ===

I will now generate the SQL query to answer your question.Here is the generated SQL query along with its execution result:
Query executed: SELECT c.segment, SUM(s.sales) AS total_sales_revenue
FROM postgres_web_sales_datasource.websales_sales s
JOIN postgres_web_sales_datasource.websales_customers c ON s.customer_id = c.customer_id
GROUP BY c.segment

Results: 3 rows x 2 columns

segment        total_sales_revenue
   Enterprise 2137724.0           
Remote Worker 1285370.2           
      Startup 3679287.8           Here's how the total sales revenue compares across different customer segments:

- **Enterprise**: $2,137,724
- **Remote Worker**: $1,285,370.2
- **Startup**: $3,679,287.8

As we can see, the "Startup" segment generates the highest total sales revenue, followed by "Enterprise", and finally "Remote Worker".

Here's a bar chart illustrating the total sales revenue for each customer segment:

![Total Sales Revenue by Segment](https://quickchart.io/chart?c=%7Btype%3A%27bar%27%2Cdata%3A%7Blabels%3A%5B%27Enterprise%27%2C%27Remote%20Worker%27%2C%27Startup%27%5D%2Cdatasets%3A%5B%7Blabel%3A%27Total%20Sales%20Revenue%27%2Cdata%3A%5B2137724%2C1285370.2%2C3679287.8%5D%7D%5D%7D%7D)

=== LLM REASONING TRACE