Cursor for data scientists on Mac: notebooks, SQL, and charts with Lazur in 2026

Setting up Cursor for data science on Mac

Start with the app. Download Cursor from cursor.com, move it to Applications, and open it. Then choose File > Open Folder and pick your project folder, not a single notebook. A folder gives the Agent your environment, your data files, and your Git history.

1. Press ⇧⌘X, search for Jupyter, and install ms-toolsai.jupyter.
2. Press ⇧⌘P, type Python: Select Interpreter, and choose a virtual environment inside the project.
3. No environment yet? Run python3 -m venv .venv in the Cursor terminal, then install your packages inside it.
4. Save your package list to requirements.txt so the setup survives a new Mac.
5. Open a .ipynb file and check that the kernel picker shows the same interpreter.

The Data Science guide does not mention macOS by name. It uses Cmd labels such as Cmd+Shift+P, so the steps translate directly. The Mac details in this page come from Cursor's desktop release notes for versions 3.25 to 3.27. Read the guide for the workflow and the release notes for Mac changes.

Notebooks in Cursor: what works and what breaks

Cursor opens .ipynb files with cell execution and AI completion once the Jupyter extension is installed. The docs also say .py files support integrated cell execution. That second option matters if your team reviews changes in Git. A notebook is JSON under the hood, so its diffs are hard to read.

The rough edges are documented in public. A feature request for Jupyter notebook support opened on September 4, 2024. In May 2025, a forum user said the Agent could not read their .ipynb file. A Cursor staff reply on May 20, 2025 said Jupyter support was not available yet. Test the current build on a copy before you trust it.

Here is a rule that works. Use notebooks for exploration and charts. Move code that must survive review into a .py file. The Python extension treats lines that start with # %% as cell markers, so you can still run one block at a time. For the notebook side in VS Code, read VS Code for data scientists on Mac.

Using Tab and Agent with pandas, NumPy, and scikit-learn

The guide says Tab and Agent work with pandas, NumPy, scikit-learn and SQL cell commands. Tab suggests the next line when the pattern is familiar. Agent handles a job you describe in plain words. Open chat with ⌘L when you want an answer, not an edit.

Worked example: a groupby that loses rows

Say you group a sales table by region to get average order value. Some rows have a blank region. pandas groupby drops rows with a missing key by default, because dropna is True. Your averages look clean, but those rows never reach the result. Ask the Agent to show a check that compares row counts before and after the groupby.

Prompts that work well for this job are short and specific:

• Rewrite this loop as a vectorized pandas operation, and keep the same output columns.
• Add a ColumnTransformer that scales numeric columns and one-hot encodes the category columns.
• Explain why this merge returns more rows than the left table. Show a duplicated() check.
• Add type hints and a docstring to this function. Do not change its behavior.
• Write a pytest test that fails if any order_id appears twice.

Two habits cause most trouble. People accept the first suggestion without running the cell. They also ask for many changes in one prompt. Ask for one change, run the cell, and check the output. Small steps keep the notebook state easy to follow.

Charts with Matplotlib, Plotly, and Seaborn

The guide says Agents can generate Matplotlib, Plotly and Seaborn code. It describes that code as something you can replicate and share. Use that. Ask for a function that takes a DataFrame and returns a figure. A function reruns next month. A cell that plots one table does not.

Give the prompt what a reviewer would ask for. Name the audience, the units, and the date range. Ask for axis labels with units and a title that states the finding. Ask the code to save the figure to a figures folder, so the chart outlives the notebook.

Querying databases from Cursor with SQL and MCP

The guide says MCP servers let the agent query a database directly. It gives a Postgres MCP configuration as an example. It also names extensions for PostgreSQL, BigQuery, SQLite and Snowflake that run queries from the editor. Pick the route your database team already supports.

1. Create a read-only database user. Grant select on the schemas you need and nothing else.
2. Store the password in an environment variable, not in a file you commit to Git.
3. Add the MCP server in Cursor's MCP settings, using the guide's example as a template.
4. Ask the agent for a query first, and read it before you run it.
5. Save useful queries in a .sql file so a teammate can review them later.

The guide says Tab and Agent also work with SQL cell commands. Keep each command short. Long queries are easier to read in a .sql file, where syntax highlighting helps.

Large datasets: Dask, Spark, and Remote-SSH

pandas reads a whole file into memory by default. A small CSV is fine. A file bigger than your Mac's memory is not. The guide suggests Dask for larger data. It also suggests connecting to Spark clusters through Remote-SSH. Pick one route before you start the analysis, not after the laptop freezes.

Start with a sample while you explore. Pass nrows to read_csv to load the first rows. Use chunksize when you need to scan the full file in pieces. Write a comment that says the notebook uses a sample, so nobody reads the results as final.

Remote-SSH runs Cursor against a machine with more memory. Your Mac stays the screen, and the other machine does the heavy work. Check with your platform team before you connect to a shared cluster.

Repeatable environments with a devcontainer

The guide includes a .devcontainer template. It uses Python 3.11 and pins pandas to 2.3.0 in requirements.txt. Pinning matters. A pandas upgrade can change how a groupby or a merge behaves. Write the version your results came from into the README.

Dev containers need Docker running on your Mac, so start Docker Desktop first. Then reopen the folder in the container. If the build fails, read the first error, not the last one. The first error usually names the cause.

Undo, commits, and Agent edits on Mac

Git is your undo button for notebooks. Commit a clean state before each Agent session. Name the commit for the task, such as 'before agent: add scaler to churn model'. If the Agent breaks cells, restore the file from that commit.

Mac undo has changed in recent releases. In 3.26, ⌘Z undoes an archive and ⇧⌘Z re-archives. In 3.27, Edit > Undo and Redo act on the focused element. Click into the editor before you press ⌘Z, or the undo may hit a different panel.

Run each Agent session the same way:

1. Commit the notebook, or copy it to a backup file.
2. Restart the kernel and run all cells once, so you know the baseline.
3. Give the Agent one task and name the cells it may touch.
4. Read the diff before you accept any edit.
5. Restart the kernel, run all cells again, then commit.

Where Lazur fits beside Cursor

Lazur is a voice assistant for the Mac that lives in the notch. Hold ⌥⌘ to ask about anything on screen, and Lazur answers out loud. Ask where something is, and Lazur draws a circle and a label around it. It does not click buttons, edit files, or operate Cursor for you.

• Explains an error in a cell, out loud, and points at the line it came from.
• Finds a control you cannot locate, such as the kernel picker, with a circle and a label.
• Guides you through a menu path one click at a time, waiting for each click.
• Drafts a Slack reply or a note, then types it at the cursor when you ask.
• Runs research in its own Chrome tabs and returns a summary and a report.

Dictation fits notebook work well. Markdown cells, commit messages and Slack updates all take typing time. Hold fn to dictate clean, formatted text at the cursor in any app. Snippets, a personal dictionary and clipboard slots keep repeated phrases short.

Notebooks often show customer rows, so think about what is on screen. Lazur listens and looks only while you hold the shortcut. Audio and the screenshot go to AI providers to answer, and they are not stored. Content is never used to train AI models. Close sensitive tabs before you hold the shortcut.

Lazur keeps a memory of what you asked and did, on your Mac. Lazur runs on Apple silicon and Intel Macs. Windows is planned, not available. Lazur is not a plugin or add-in for Cursor, and it has no partnership with Cursor.

Pricing for Cursor and Lazur

Cursor's pricing page lists a Free plan at $0 a month, with limited agent and chat requests. It lists Plus at $8 a month, with basic usage in a shared AI usage pool. Plan wording changes, so check the live page before you pay.

Lazur starts with a 3-day Pro trial that needs no credit card. The trial starts the first time you open the app. Plan around AI actions, not dictation, because dictation is unlimited on both plans.

Mistakes data scientists make in Cursor

• Accepting an Agent edit to a notebook with no commit. One bad edit can cost you a clean state.
• Trusting a groupby or merge because it ran. Check row counts before and after.
• Connecting a database with write access. Start with a read-only user.
• Keeping the project in Desktop or Documents, then wondering why new files do not show up.
• Running cells on the wrong interpreter. Check the kernel picker first.

The kernel mistake is the easiest to miss. Check the kernel picker before every long run, and compare it with the interpreter in the status bar.

What the research says about AI coding help

These figures describe developers in general, not data scientists. In the Stack Overflow 2025 survey, 47.1% of all respondents use AI tools daily. Among professional developers, 50.6% do. Use these numbers as context, not as proof that your notebook work will speed up.

A study of 57 developers at one tech company found 88% perceived a productivity gain. It also found 13 of 57, or 22%, saw little or no gain. The study did not measure time saved. Treat it as a reason to test your own workflow.

Next steps for your first session

1. Install ms-toolsai.jupyter and select the project interpreter.
2. Open a copy of one notebook and run every cell once.
3. Commit that clean state, then ask the Agent for one small change.
4. Create a read-only database user before you connect an MCP server.
5. Hold ⌥⌘ and ask Lazur to walk you through the kernel picker.

For the developer side of this setup, read Cursor for developers on Mac. For the voice side of Cursor, see voice assistant for Cursor on Mac. Both pages cover related Cursor habits.