Traditionally, setting up PostgreSQL meant installing it on your machine, changing lots of settings, and typing many commands by hand.

💡 What is PostgreSQL?
PostgreSQL is a popular open‑source database engine that stores data in tables and speaks SQL, and we’ll be using it in this project to model a realistic e‑commerce system.

💡 What is a database?
A database is a structured place where applications store and organize information (like customers, products, and orders) so they can quickly search, update, and combine that data when users interact with the app.

In this project, Cursor + MCP act like a control tower. You’ll use plain English to ask for what you want and let Cursor and the MCP translate that to commands and SQL that make it happen.

💡 What's MCP? How is it different from just using Cursor's chat?
MCP (Model Context Protocol) is a standard that lets AI models (like Claude in Cursor) connect to external tools and services. Unlike regular Cursor chat which can only read and edit files, when you use MCP servers, Cursor can:

• Create and control Docker containers
• Execute SQL queries on databases
• Manage infrastructure through natural language

This means you can control real infrastructure and services directly from Cursor's chat, rather than just editing code files.

If you're up for a bit of a challenge, quiz yourself on the key concepts up ahead in this project! Don't be too nervous, you'll also get a quiz at the end of this project, to recap what you've learned.

Let's get your environment ready! We'll install Docker Desktop for running containers and uv for managing Python packages.

In this step, you're going to:

Install Docker Desktop

Docker Desktop provides everything you need to run Docker containers on your computer.

💡 What is Docker and Docker Desktop?
Docker is a tool that lets you package an application (like PostgreSQL) together with everything it needs to run into a lightweight bundle called a container. A container is like a self‑contained mini‑computer that always has the right versions of libraries and settings, so your app runs the same way on any machine.

Docker Desktop is the app that makes it easy to run those containers on your laptop – it includes the Docker engine, a graphical dashboard, and all the background services. In this project, Docker Desktop will run a PostgreSQL container for you instead of you installing PostgreSQL directly on your operating system, which keeps your system cleaner and makes it easy to start, stop, or delete the database when you're done.

First, let's check if you already have Docker Desktop installed.

• Open Terminal (Mac) or PowerShell (Windows).
• Run the following command:

Next up! We'll set up MCP servers that let Cursor talk to Docker and PostgreSQL for you.

💡 What's MCP? How is it different from just using Cursor's chat?
MCP (Model Context Protocol) is a standard that lets AI models (like Claude in Cursor) connect to external tools and services. Unlike regular Cursor chat which can only read and edit files, when you use MCP servers, Cursor can:

• Start and stop Docker containers
• Run SQL queries on your databases from chat
• Help you set up and manage these tools by following your instructions

In other words, MCP lets Cursor work with your actual running tools (like Docker and PostgreSQL), not just the code sitting in your editor.

In this step, you're going to:

Initialize Your Python Project

MCP servers need a Python environment to run. Let's create one using uv!

First, make sure you're in your MCP-data-series folder in the terminal.

• Run the following command:

🙋‍♀️ I'm not in MCP-data-series!
Run cd Desktop/MCP-data-series (or wherever you created the folder) to navigate there.

Now let's initialize a new uv project.

• Run the following command:

💡 What does uv init do?
This command creates a Python project structure with several files including pyproject.toml (tracks dependencies), .gitignore (excludes files from git), README.md (project documentation), and main.py (example Python script).

You should see a few new files appear in your MCP-data-series folder!

🙋‍♀️ I see "Adding 'MCP-data-series' as member of workspace..."
This message appears if uv detected an existing Python workspace in a parent folder (like your Desktop or home directory). This is fine! Your MCP-data-series project will work correctly as part of that workspace.

Configure Cursor MCP Settings

Now comes the magic - we'll tell Cursor about our MCP servers by adding them to a configuration file. Think of this as giving Cursor the keys to Docker and PostgreSQL. Once configured, Cursor will be able to create containers, run SQL queries, and manage your database infrastructure directly through its chat interface.

• Click the settings icon (gear icon) in the top right of Cursor.

• Select Tools & MCP from the left-hand side settings menu.

• Scroll down.
• Click "Add Custom MCP" (or "New MCP Server" if you already have MCPs configured).

💡 Button says "New MCP Server"?
If you already have other MCP servers configured in Cursor, the button will say "New MCP Server" instead of "Add Custom MCP". This is perfectly normal - just click it to add another MCP server!

The file: mcp.json will open showing your Cursor MCP configurations. We'll add both Docker MCP and Postgres MCP to your configuration.

💡 What does this configuration do?
This JSON file tells Cursor how to run MCP servers:

• command - The program to execute (we use uv to run Python packages)
• args - Arguments passed to the command (tells uv which MCP package to run)
• env - Environment variables like connection strings and socket paths

Now save the file.

• Press Cmd + S (Mac) or Ctrl + S (Windows/Linux).

Restart Cursor

For Cursor to pick up the new MCP servers, we need to restart it completely.

• Quit Cursor - make sure it's not just minimized!

💡 How do I quit Cursor?

• Mac: Go to Cursor → Quit Cursor, or press Cmd+Q on your keyboard.
• Windows: Go to File → Exit or press Alt+F4 on your keyboard.

• Reopen Cursor from your Applications folder (Mac) or Start menu (Windows).

💡 Why restart Cursor?
MCP configurations are loaded when Cursor starts. Restarting ensures Cursor reads your new configuration and establishes connections to both the Docker and Postgres MCP servers.

Now let's verify the MCP servers connected successfully.

• Click the settings icon (gear icon) in the top right.

• Select MCP from the left sidebar.

You should see both docker and postgres with green indicators showing they're connected!

🙋‍♀️ My MCPs aren't green!
If you see red indicators or error messages instead of green ones, don't worry - this is usually a configuration issue. Get help debugging MCP connection issues. You can also share your error with the NextWork community!

Awesome! You've successfully configured both MCP servers. In the next step, we'll put them to work and build a real PostgreSQL database using nothing but chat.

It's time! So far, you’ve set up the tooling (Docker, Python, uv, and MCP servers). In this step, you’re finally going to bring the database to life: start PostgreSQL inside Docker, load realistic e‑commerce data, and visualize the tables you’ve created.

💡 What is a database?
A database is a structured place for storing and organizing information so that apps can quickly save, search, and update it. For example, an online store might use a database to keep track of customers, products, and orders instead of trying to manage all that information in separate spreadsheets.

💡 What is PostgreSQL?
PostgreSQL (often shortened to “Postgres”) is a popular open‑source relational database – it stores data in tables with rows and columns, and lets you query that data using SQL. Many startups and large companies use PostgreSQL in production because it’s powerful, reliable, and free, which makes it perfect for projects like this where you want to work with “real world” database tech.

💡 How do Docker, Python, uv, and MCP fit together here?
In this project, the MCP servers (Docker MCP and Postgres MCP) are small Python programs. Python is the language they’re written in, and uv is the tool that installs their dependencies and runs them in a clean Python environment. Docker is responsible for actually running your PostgreSQL database in a container.

When you type in Cursor, Cursor calls the MCP servers (run via uv), the Docker MCP talks to Docker to start or manage the Postgres container, and the Postgres MCP talks directly to the database inside that container to run SQL and manage schemas and users.

In this step, you're going to:

Create PostgreSQL Container

Here's where the magic happens! We're about to create a PostgreSQL database in Docker, ready to store and query thousands of rows of e-commerce data. 🎯

• Open Cursor's AI Chat Pane (you could also press Ctrl + L or Cmd + L on your keyboard).

💡 What's Cursor chat?
Cursor chat is where you interact with the AI assistant. When you type messages here, Cursor can use the MCP servers we configured to actually perform actions - like creating Docker containers!

Now let's create the PostgreSQL container.

• Send this prompt:

💡 What does this prompt do?

This message is asking Cursor (through the Docker MCP) to set up a ready‑to‑use PostgreSQL database for you.

• postgres:16 is the version of PostgreSQL we want. Think of it like saying "install PostgreSQL version 16" instead of some random older version.
  
• An image is like a template for a container – it's a pre‑packaged recipe that says "here's how to run PostgreSQL with all the right files and settings." Docker uses this PostgreSQL 16 image to create the actual running database.
  
• A container named pg-local is the running PostgreSQL database created from that image. Giving it a name just makes it easier to find and manage later.
  
• Mapping port 5432 means "open door number 5432 on your computer and connect it to the database inside Docker." PostgreSQL is configured to listen on port 5432, which just means it watches that door for incoming requests. When tools outside Docker (like MCP, psql, or apps) want to talk to the database, they send network traffic to localhost:5432, and Docker passes it through that door into the container.
  
• The username and password are like login details for your database. Just like you need an account to sign into a website, tools connecting to PostgreSQL must prove who they are. Using a separate database user (like app with password app) lets you control what that user is allowed to do and keeps things safer than sharing a super‑powerful admin account for everything.

Cursor will analyze your request and propose using the Docker MCP.

You might see a tool call appear in the chat.

• Select Run so Cursor can use the tool call to create the Docker container.

💡 What is a tool call?
A tool call is Cursor's way of making a structured request to an MCP server to run a specific function. When you ask Cursor to create a Docker container, it generates a tool call to says "use this MCP function (like mcp_docker_create-container) with these parameters."

Cursor shows you this tool call in the chat so you can see exactly what's about to happen before it runs.

🙋‍♀️ Cursor isn't connecting to Docker!
Hmm! Here are a few troubleshooting tips if Cursor can't connect to the Docker MCP...

1. Make sure your Cursor chat is in Agent mode - not Ask mode!
2. Check the Tools & MCP page in your Cursor Settings - is the Docker MCP showing any errors? Make sure to expand the MCP to view detailed error message, which you can paste into your Cursor chat to troubleshoot!
3. Still not connecting? Troubleshoot here!

It'll take about 10-15 seconds for PostgreSQL to fully start up inside the container.

What do you see in your Cursor chat once it's done running MCP tool calls?

Configure Database Users and Schema

Great! Your container is running. Now let's set up how your application will safely talk to the database.

💡 What's an application user? Why do we have them?

When we started the PostgreSQL container, we set it up with a username and password (app / app) and a demo database. That app login is an application user - it’s the account your app and the Postgres MCP use for everyday work like reading and writing data. In contrast, postgres is the database's built‑in superuser, only for rare admin/maintenance tasks.

That way, if your app (or tools using that account) are ever compromised, the attacker is mostly limited to what the app user can do.

Now let's configure that application user and give it its own schema.

• Send this prompt:

💡 What does this prompt do?

This prompt tells Cursor (using the Postgres MCP) to:

• Make sure the app user can fully use the demo database (create tables, insert data, run queries, etc.). In production you’d lock this down even further (i.e. you wouldn't give your app user permissions to demo), but this separation is your first step towards separating an application user from the superuser.

• Create a schema called app and make the app user its owner. This keeps your app’s tables grouped together in one place.

💡 What's a schema vs a database?

A database (like demo) is the whole “container” that holds all of your data. A schema (like app) is a named section inside that database where related tables live together.

Think of it like your laptop: the database is the entire hard drive, and schemas are folders inside it. You might keep your main app tables in an app folder and your analytics/reporting tables in a reporting folder, even though they’re all on the same drive.

You should see success messages for each command!

Download Demo Data

Now let's fill this database with real data! We've prepared a SQL file packed with realistic e-commerce data: customers, products, orders, and more. Over 40,000 rows ready to go. 📊

• Click demo_data.sql to download the file.
• Save it to your MCP-data-series folder with the name demo_data.sql.

Verify the file is in your MCP-data-series folder:

💡 What is SQL?
SQL (Structured Query Language) is the standard language used to tell relational databases like PostgreSQL what to do - for example, “create this table”, “insert this order”, or “find all customers in Canada”. Instead of clicking around in a UI, you write SQL statements, and the database executes them to store, update, or fetch data.

💡 What's in demo_data.sql?
This SQL file contains:

• 4 tables: customers, products, orders, and order_items with their relationships
• 2,000 customers with emails, registration dates, countries, and tier levels (bronze/silver/gold/platinum)
• 1,000 products across different categories with prices and stock quantities
• 10,000 orders with statuses, dates, and regional data
• 30,000+ order items linking orders to products with quantities and prices

This realistic e-commerce dataset is perfect for practicing SQL queries and database analysis!

Load Demo Data

Let's load the demo data into your database.

In Cursor's terminal, run this command:

💡 What does this command do?

1. This command reads the demo_data.sql file and pipes it (|) directly into the PostgreSQL container.
2. The docker exec -i pg-local psql -U app -d demo part executes the SQL commands inside the container as the app user in the demo database.

You should see SQL output scrolling by as tables are created and data is inserted.

Verify Your Setup

Let's verify everything is connected and working.

• Send this prompt to Cursor:

Cursor should respond with information about your running Docker container (pg-local), your PostgreSQL connection details, and the tables in your database (customers, products, orders, order_items).

Visualize Your Database Schema

Let's create a visual diagram showing how all your tables connect together. This is the kind of diagram database architects create when designing systems. 👀

• Send this prompt to Cursor:

Cursor will read your database schema and generate a visual diagram showing all tables, their columns, relationships, and sample data!

💡 What's an ER diagram?
An Entity-Relationship (ER) diagram is a visual representation of your database structure. It shows tables as boxes, columns inside each box, and arrows connecting tables to show relationships (like how orders connect to customers). The diagram also displays sample data so you can see real values from your database.

💡 How do you “read” this diagram?
Start by picking one table box (for example customers), then follow the arrows to see which other tables depend on it (like orders). The sample rows help you connect column names to real‑world meaning – for example, a customer_id in orders should match an id in customers, just like a lookup between two related spreadsheets.

How do companies like Instagram, Spotify, and Apple keep their databases running fast, even with millions of users?

By now, you’ve built and populated a realistic PostgreSQL database in Docker, and you can explore it through Cursor and the Postgres MCP. In this secret mission, you’ll shift into performance‑tuning mode - you'll learn to spot slow queries, understand how your database thinks, and add smart optimizations that make everything run smoother.

Nice work completing this project! Now let's clean up the resources we created to keep your system tidy.

Resources to delete:

You did it! You've built a complete PostgreSQL database setup that you can control using natural language in Cursor.

What you learned:

• ⚙️ How MCP (Model Context Protocol) connects code editors to external tools
• 🐳 Docker fundamentals: containers, images, and port mapping
• 🐘 PostgreSQL basics: users and schemas, plus how indexes can speed up queries (explored further in the Secret Mission)
• 📊 Database performance: query plans, execution analysis, and optimization
• 💬 How to manage infrastructure by just typing what you want

Ready to quiz yourself? 💪

What's next?

In Project #2 of this Data Engineering x MCP series (coming soon), get ready to transform your raw data into customer analytics with the DBT MCP!

Make sure to join the NextWork Community to be the first to hear when it's out 🤝

🚀 p.s. Does it say "Still tasks to complete!" at the bottom of the screen?

This means you still have screenshots left to upload, or questions left to answer!

1. Press Ctrl+F (Windows) or Command+F (Mac) on your keyboard.
2. Search for the text Return to later.
3. Jump straight to your incomplete tasks!
4. 🙋‍♀️ Still stuck? Ask the community!