Getting Started with JupyterLab on macOS using Python 3.14

Getting Started with JupyterLab on macOS using Python 3.14

Whether you're building AI applications, analyzing data, automating cloud infrastructure, or learning Python, one tool consistently appears across tutorials, enterprise projects, and research environments: Jupyter.

From Data Scientists and Machine Learning Engineers to Cloud Architects and DevOps professionals, Jupyter has become the preferred environment for experimenting with code, documenting ideas, visualizing data, and building production-ready prototypes.

Over the past few years, I have used Jupyter extensively while developing Retrieval-Augmented Generation (RAG) applications, experimenting with Large Language Models (LLMs), testing AWS services through Boto3, exploring Azure and Google Cloud SDKs, and validating proof-of-concept architectures before moving them into production.

For me, Jupyter is usually where an idea becomes testable before it becomes a script, service, or production workflow.

If you're planning to follow my upcoming Python series covering AWS Boto3, Azure SDK for Python, Google Cloud Client Libraries, Amazon Bedrock, Agentic AI, and cloud automation, this article will help you set up the development environment we'll use throughout the series.

In this guide, we'll install JupyterLab on macOS using Python 3.14, create an isolated Python environment, verify the installation, and prepare our machine for future AI and cloud development.

What is Jupyter?

Jupyter is an open-source interactive development environment that allows you to write and execute code one step at a time while documenting your work alongside it.

Unlike a traditional Python script that runs from beginning to end, Jupyter lets you execute individual sections of code, inspect variables, visualize results, modify your logic, and continue working without restarting the program.

A Jupyter notebook can contain:

• Python code
• Documentation
• Architecture notes
• Tables
• Charts and visualizations
• Images
• Mathematical equations
• Interactive widgets

Think of it as combining a Python interpreter, documentation editor, terminal, and visualization tool into a single browser-based workspace.

Why Jupyter Has Become the Standard for AI Development

Modern AI development is highly iterative. Engineers rarely write hundreds of lines of code before executing a program. Instead, they continuously experiment, validate assumptions, compare outputs, and refine their approach.

Jupyter was designed for exactly this workflow.

Rather than executing an entire application, you can run one cell, inspect the output, adjust the code, and continue building incrementally.

Write Code
      |
      v
Run Cell
      |
      v
View Results
      |
      v
Modify Logic
      |
      v
Run Again

This interactive workflow makes development significantly faster, especially when working with machine learning models, cloud APIs, data analysis, or prompt engineering.

Today, Jupyter is commonly used for:

• Artificial Intelligence
• Machine Learning
• Deep Learning
• Generative AI
• Large Language Models (LLMs)
• Retrieval-Augmented Generation (RAG)
• Data Engineering
• Cloud Automation
• Data Analytics
• Financial Modeling
• Scientific Research

Jupyter Notebook vs. JupyterLab

If you've searched for Jupyter installation guides, you've probably seen references to both Jupyter Notebook and JupyterLab.

Originally, Jupyter Notebook was the primary interface for creating notebooks. It provided a simple web-based editor focused on a single notebook at a time.

JupyterLab builds upon that foundation and introduces a more complete development environment.

Classic Notebook
      |
      +-- Single Notebook
      +-- Basic Interface

JupyterLab
      |
      +-- Multiple Notebooks
      +-- File Browser
      +-- Integrated Terminal
      +-- Text Editor
      +-- Tabs
      +-- Extensions

JupyterLab supports everything available in the classic Notebook interface while adding capabilities that make it feel much closer to a modern Integrated Development Environment (IDE).

Unless you have a specific requirement for the classic Notebook interface, I recommend installing JupyterLab. Throughout this article series, all examples will work perfectly in JupyterLab.

Why Use a Virtual Environment?

One of the most common mistakes Python developers make is installing every package globally.

While this may work initially, it often leads to dependency conflicts as different projects require different versions of the same library.

Virtual environments solve this problem by creating an isolated Python environment for each project.

Keeping the environment isolated may feel like an extra step at first, but it saves a lot of cleanup later when different AI, data, or cloud libraries require different dependency versions.

Mac
 |
 +-- Python 3.14
 |
 +-- Project A
 |      |
 |      +-- Virtual Environment
 |      +-- Packages
 |
 +-- Project B
 |      |
 |      +-- Virtual Environment
 |      +-- Different Packages
 |
 +-- Project C
        |
        +-- Virtual Environment
        +-- Independent Packages

Each project maintains its own dependencies without affecting any other project on your machine.

This is considered a Python best practice and is the approach we'll follow throughout this series.

Prerequisites

Before installing JupyterLab, verify that Python is already installed.

Open Terminal and execute the following command.

python3 --version

Example output:

Python 3.14.6

Next, verify that pip is installed.

python3 -m pip --version

Example output:

pip 26.x.x from /opt/homebrew/lib/python3.14/site-packages/pip (python 3.14)

If both commands execute successfully, your machine is ready for the Jupyter installation.

Creating a Workspace

I prefer keeping notebooks in a dedicated workspace rather than scattering them across different folders.

Create a working directory by running:

mkdir ~/jupyter
cd ~/jupyter

You can choose any directory name you prefer. The goal is simply to keep your notebooks and future projects organized.

Creating a Virtual Environment

Inside the workspace, create a virtual environment.

python3 -m venv .venv

This creates a new directory named .venv that contains an isolated Python interpreter and package repository dedicated to this project.

Next, activate the environment.

source .venv/bin/activate

Your Terminal prompt should now look similar to the following:

(.venv) your-mac jupyter %

The (.venv) prefix indicates that you're working inside the virtual environment. Any packages installed from this point forward will remain isolated from the rest of your system.

Upgrade pip

Before installing additional software, it's always a good idea to upgrade pip to the latest version.

python -m pip install --upgrade pip

This ensures you'll receive the latest package management improvements and compatibility updates.

Installing JupyterLab

With the virtual environment activated, installing JupyterLab requires a single command.

python -m pip install jupyterlab

Depending on your internet connection, the installation may take a minute or two as Python downloads JupyterLab along with its required dependencies.

Once complete, your Mac is ready to launch JupyterLab and begin building notebooks for Python development, AI experimentation, cloud automation, and data analysis.

This part intentionally stops after installation so the environment is clean and ready. In the next part of this guide, we'll launch JupyterLab, create our first notebook, install commonly used Python libraries, discuss packages used for AI development, and review several troubleshooting tips that can save hours when setting up a new development environment.

Continue the JupyterLab series:

• Article 2: Launching JupyterLab