Real Python

Coding With OpenCode: AI-Assisted Python

2026-08-11T14:00:00+00:00

OpenCode is an open-source AI coding agent that runs in your terminal and lets you analyze and refactor a Python project through conversational commands. In this video course, you’ll install it on your system, set it up with a free Google Gemini API key, and learn the basics of how to use it in your daily programming work.

OpenCode works as a conversational assistant you explicitly direct. Ask it to analyze functions, refactor code, or explain issues. Press Enter to send your query, and you’ll get a response with full awareness of your project context. It supports more than seventy-five AI providers, including Anthropic, OpenAI, and Google Gemini.

If you’re a Python developer who prefers working in the terminal, OpenCode offers deliberate, context-aware assistance and a customizable AGENTS.md configuration file.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Coding With OpenCode: AI-Assisted Python

2026-08-11T12:00:00+00:00

In this quiz, you’ll test your understanding of the concepts covered in Coding With OpenCode: AI-Assisted Python.

By working through this quiz, you’ll revisit how to install OpenCode, connect it to a free Google Gemini API key, and use Plan and Build modes to analyze and refactor a Python project without leaving your terminal.

You’ll also check what you know about OpenCode sessions, the command palette, and switching between AI models on the fly.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Qt Designer and Python: Build Your GUI Applications Faster

2026-08-10T14:00:00+00:00

Qt Designer is a tool that lets you build the graphical user interface (GUI) of a PyQt application visually, by dragging and dropping widgets onto a form instead of writing layout code by hand. In Python, you save those designs as .ui files and load them into your apps, which can speed up your GUI development considerably.

By the end of this tutorial, you’ll understand that:

Qt Designer produces XML-based .ui files that don’t depend on a particular Qt binding, so you build your GUI visually and then use it from PyQt6 code.
You install the PyQt6 bindings with pip install pyqt6 and get the Qt Designer app from PySide6, your system package manager, or the official Qt installer.
The pyuic6 command turns a .ui file into a Python module, while uic.loadUi() reads the same file at runtime.
A single Qt Designer form can hold a complete main window with menus, toolbars, and a status bar, or a standalone dialog.
You connect a widget’s signals to slots visually in Qt Designer, without hand-writing the connection code.

You’ll also see when it makes sense to reach for Qt Designer instead of hand coding your GUIs in plain Python.

For a better understanding of the topics in this tutorial, you can check out the following resources:

You’ll put all this knowledge together by using the GUIs that you’ll build with Qt Designer in a sample text editor application. You can get the code and all the required resources to build this application by clicking the link below:

Get the Source Code: Click here to get the source code you’ll use to learn about creating Python GUI applications with Qt Designer in this tutorial.

Take the Quiz: Test your knowledge with our interactive “Qt Designer and Python: Build Your GUI Applications Faster” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Qt Designer and Python: Build Your GUI Applications Faster

Test your knowledge of Qt Designer for Python. Build PyQt GUIs visually with drag-and-drop, signals and slots, and .ui files.

Getting Started With Qt Designer

Qt Designer is a Qt tool that provides you with a what-you-see-is-what-you-get (WYSIWYG) user interface to create GUIs for your PyQt applications productively and efficiently. With this tool, you create GUIs by dragging and dropping QWidget objects on an empty form. After that, you can arrange them into a coherent GUI using different layout managers.

Qt Designer also allows you to preview your GUIs using different styles and resolutions, connect signals and slots, create menus and toolbars, and more.

Qt Designer is platform and programming language independent. It doesn’t produce code in any particular programming language, but it creates .ui files. These files are XML files with detailed descriptions of how to generate Qt-based GUIs.

You can translate the content of .ui files into Python code with pyuic6, which is a command-line tool that comes with PyQt. Then you can use this Python code in your GUI applications. You can also read .ui files directly and load their content to generate the associated GUI.

Installing and Running Qt Designer

There are several ways to install Qt Designer, and the right one depends on your platform. Qt Designer is a separate application, so you’ll set up two separate pieces: the PyQt6 bindings that your code will use, and the Qt Designer application itself.

First, create and activate a Python virtual environment and install PyQt6 with pip:

$ python3 -m venv ./venv
$ source venv/bin/activate
(venv) $ python -m pip install pyqt6

This installs PyQt6 along with a private copy of the required Qt libraries. It also gives you pyuic6, a command-line tool that you’ll use later to turn your .ui files into Python code.

Note: In PyQt5, you installed Qt Designer through the pyqt5-tools package. In PyQt6, pyqt6-tools is no longer maintained and won’t install on current Python versions, so you’ll install Qt Designer on its own instead.

Next, install the Qt Designer application. Because Qt Designer saves its work in binding-agnostic .ui files, you can get the tool in whatever way is most convenient for your platform.

Even though your application code uses PyQt6, the quickest cross-platform way to get Qt Designer is to install PySide6, which ships with a ready-to-run copy of the tool:

(venv) $ python -m pip install pyside6
(venv) $ pyside6-designer

The pyside6-designer command launches the same Qt Designer that you’d get directly from Qt. You design your GUI here and then load the resulting .ui file from PyQt6.

You can also install Qt Designer in a few platform-specific ways:

Read the full article at https://realpython.com/qt-designer-python/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #306: Programmatically Developing LLM Prompts With DSPy

2026-08-07T12:00:00+00:00

How can you move from manually writing prompts for an LLM application toward defining them programmatically? This week on the show, Brett Kennedy returns to discuss his new book "Building LLM Applications with DSPy."

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: How to Use Type Hints for Multiple Return Types in Python

2026-08-07T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Use Type Hints for Multiple Return Types in Python.

By working through this quiz, you’ll revisit how to annotate a function that returns one value of alternative types, and how to describe several pieces of data at once with a tuple.

You’ll also practice annotating callbacks, factory functions, and generators, defining type aliases to keep long annotations readable, and checking your work with a static type checker.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Python's Assignment Operator: Write Robust Assignments

2026-08-06T12:00:00+00:00

In this quiz, you’ll test your understanding of Python’s Assignment Operator: Write Robust Assignments.

By working through this quiz, you’ll revisit how to write assignment statements, work with parallel assignment and iterable unpacking, use augmented assignments, and explore variants like the walrus operator and managed attributes.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Validating Data With Pointblank in Python

2026-08-05T14:00:00+00:00

At 3 a.m., a scheduled data pipeline fails with an AssertionError, and the traceback can’t tell you whether the cause is one stray row or a systematic bleed that should halt the entire run. Pointblank, a Python data-validation library, sharpens that decision: it checks a Polars or pandas DataFrame against rules you declare, and each rule accumulates failures until it crosses a threshold you set.

When a rule trips, you learn its name, the offending column, and the fraction of rows that failed, and Pointblank’s pb command-line tool wires that signal into a continuous integration step.

By the end of this tutorial, you’ll understand that:

A validation plan chains col_vals_*() checks onto pb.Validate and runs when you call .interrogate().
Thresholds turn a pass/fail check into warning, error, and critical tiers based on the fraction of failing rows.
Actions trigger messages or callbacks when a step crosses a threshold, letting a policy decide the outcome.
get_sundered_data() routes the passing or failing rows out of an interrogated plan, depending on its type argument.
A plan stored as YAML runs through the pb command-line tool, where --fail-on critical returns a nonzero exit code for CI.

Pointblank can also validate SQL tables in DuckDB or PostgreSQL directly, so it complements parse-time schema tools such as Pydantic rather than replacing them. In this tutorial, you’ll see where Pointblank overlaps with Pandera and Great Expectations, two other Python data-validation libraries, and when to choose each one.

To get the most out of this tutorial, you should feel comfortable reading basic Polars or pandas DataFrame code, running Python scripts from the command line, and working in a terminal with a package manager like uv or pip. A virtual environment helps keep those installs isolated.

To follow along, you’ll validate a small built-in dataset, add thresholds and actions, sunder a messier table of atom data, and finally move the whole plan into YAML.

Get Your Code: Click here to download the free sample code you’ll use to validate DataFrames with Pointblank, from severity thresholds and row sundering to YAML-driven checks.

Take the Quiz: Test your knowledge with our interactive “Validating Data With Pointblank in Python” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Validating Data With Pointblank in Python

Validate data in Python with Pointblank. Declare quality checks, split clean rows from failing ones, and rerun validation plans from YAML.

Get Started With Pointblank in Python

Start by running one validation plan against a built-in dataset. The examples use uv because it runs self-contained scripts that declare and manage their own dependencies through inline script metadata.

If you don’t already have uv, you can install it using the standalone installer by running the command below:

PS> powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

$ curl -LsSf https://astral.sh/uv/install.sh | sh

If you don’t have curl installed on your system, then you can use wget as shown below:

$ wget -qO- https://astral.sh/uv/install.sh | sh

Now that you have uv, the script below declares pointblank[pl] as a dependency. The [pl] suffix is a pip extra that pulls in Polars alongside Pointblank, so uv run pointblank_quickstart.py builds an isolated environment and runs the file in one step.

Note: If you’d rather not use uv, install the dependencies with python -m pip install 'pointblank[pl]' in a virtual environment and run each script with python instead.

Pointblank ships a small example table named small_table with thirteen rows and eight columns. Its columns carry deliberately generic names, a through f alongside two date columns, which keeps the focus on the validation mechanics rather than any one domain.

The first script validates three of them, one for each common kind of check. Since small_table has only thirteen rows, you can print the whole thing from the Python REPL and see every value before you run anything.

The scripts in this tutorial declare their own dependencies, but a bare REPL doesn’t, so launch one with Pointblank and Polars already available:

$ uv run --with 'pointblank[pl]' python

Then load the dataset and print the three columns you’ll validate:

>>> import pointblank as pb
>>> import polars as pl
>>> small_table = pb.load_dataset("small_table", tbl_type="polars")
>>> with pl.Config(tbl_rows=13):
...     print(small_table.select(["c", "d", "f"]))
shape: (13, 3)
┌──────┬─────────┬──────┐
│ c    ┆ d       ┆ f    │
│ ---  ┆ ---     ┆ ---  │
│ i64  ┆ f64     ┆ str  │
╞══════╪═════════╪══════╡
│ 3    ┆ 3423.29 ┆ high │
│ 8    ┆ 9999.99 ┆ low  │
│ 3    ┆ 2343.23 ┆ high │
│ null ┆ 3892.4  ┆ mid  │
│ 7    ┆ 283.94  ┆ low  │
│ 4    ┆ 3291.03 ┆ mid  │
│ 3    ┆ 843.34  ┆ high │
│ 2    ┆ 1035.64 ┆ low  │
│ 9    ┆ 837.93  ┆ high │
│ 9    ┆ 837.93  ┆ high │
│ 7    ┆ 833.98  ┆ low  │
│ 8    ┆ 108.34  ┆ low  │
│ null ┆ 2230.09 ┆ high │
└──────┴─────────┴──────┘

You’ll write one rule for each of these three columns, listed in the same order as the table, with bounds chosen to illustrate the check rather than to describe real measurements:

c is an integer column that the plan requires to be non-null, and two of its rows are null.
d is a numeric column that the plan requires to fall between 0 and 5000, and one row, 9999.99, falls outside that range.
f is a categorical column that the plan limits to the labels low, mid, and high, and every row already matches.

With the whole table in view, the failure counts you’ll see in a moment are no surprise: two null c values, one out-of-range d value, and a clean f column. When you validate your own data, you’d swap these for your real columns and the thresholds your pipeline expects.

Read the full article at https://realpython.com/python-pointblank/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Validating Data With Pointblank in Python

2026-08-05T12:00:00+00:00

In this quiz, you’ll test your understanding of Validating Data With Pointblank in Python.

By working through this quiz, you’ll revisit how to declare validation rules, set severity thresholds, sunder clean rows from dirty ones, and rerun a validation plan from YAML with the pb command-line tool.

Data validation keeps a bad row from quietly breaking the rest of your pipeline, so it’s worth getting comfortable with these checks.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Sending Emails Using Python

2026-08-04T14:00:00+00:00

You probably found this video course because you want to send emails with Python to automate confirmation messages, password resets, or scheduled notifications. Python’s standard library covers the whole pipeline, from making a server connection to building the message and sending it to one or many recipients. This course walks through every step in working code.

By the end of this course, you’ll understand that:

A safe testing setup uses a throwaway Gmail account with an app password, a local aiosmtpd debug server, or a privacy-focused provider like Posteo or Proton Mail.
A secure SMTP session uses .SMTP_SSL() with ssl.create_default_context(), which validates the server certificate and encrypts your credentials and message content.
The EmailMessage class from the email package assembles plain text, HTML alternatives, file attachments, and personalized fields through .set_content(), .add_alternative(), and .add_attachment().
Setting msg["reply-to"] or any other RFC 5322 header on an EmailMessage routes replies to a different mailbox than the sender address.
For high-volume sending, transactional email services like SendGrid, Mailgun, and Brevo provide deliverability, statistics, and API libraries that go beyond what smtplib alone offers.

Before you jump into the code, you’ll set up a throwaway email account or a local debug server so you can experiment freely without spamming real inboxes.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: K-Means Clustering in Python: A Practical Guide

2026-08-04T12:00:00+00:00

In this quiz, you’ll test your understanding of K-Means Clustering in Python: A Practical Guide.

By working through this quiz, you’ll revisit how k-means groups data into clusters, how the main clustering categories compare, and how to build and tune a k-means pipeline with scikit-learn.

k-means is one of the oldest and most approachable clustering methods, which makes it a great entry point into unsupervised machine learning with Python.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Sending Emails Using Python

2026-08-04T12:00:00+00:00

In this quiz, you’ll test your understanding of the concepts covered in Sending Emails Using Python.

By working through this quiz, you’ll revisit how SMTP carries a message from your code to a mail server, how the EmailMessage class assembles plain text, HTML alternatives, and file attachments, and how SMTP_SSL secures a connection to a real provider.

You’ll also check what you know about CC, BCC, and reply-to headers, base64 encoding for binary attachments, and when a transactional email service beats sending mail yourself.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

MCP Gets Its Biggest Rewrite and Other Python News for August 2026

2026-08-03T14:00:00+00:00

Some months, the AI news is just a trickle of point releases. But this past month was like a firehose. The protocol that connects agents to your tools got its biggest rewrite since inception, and Anthropic, OpenAI, Google, Meta, Moonshot, and a brand-new lab founded by a former OpenAI CTO all shipped new models in a single month.

Besides the models, the rest of the Python ecosystem was equally active. The major scientific libraries dropped support for 3.13t and settled on 3.14t as their free-threaded target. Python 3.15 shipped its final beta, the JIT team responded to the Steering Council’s ultimatum, the PSF opened nominations for its board and the first-ever Packaging Council, and Astral shipped breaking minors of uv and Ruff. The MCP rewrite comes first.

Join Now: Click here to join the Real Python Newsletter and you’ll never miss another Python tutorial, course, or news update.

MCP Drops Sessions and Goes Stateless

Two things landed on July 28, and together they make this the most disruptive month MCP has had since it launched. The 2026-07-28 specification was finalized with a revision that changes how servers are deployed, and the Python SDK shipped a 2.0 the same day, renaming the class most Python servers are built on.

What the New Spec Changes

The main change is that the protocol is now stateless. A client used to open with a handshake and then carry a session ID through the rest of the conversation. Both are gone. Protocol version and client capabilities now ride along on every request, and a new server/discover call fetches what a server can do.

Under the new specification, any request can land on any instance, and a plain round-robin load balancer is enough. If you only call MCP servers, then the stateless switch is what affects you the most.

If you ship an MCP server, then your migration list looks like this:

Remove the session machinery: The handshake and the session header are both gone, so anything you built to track a client between requests goes with them.
Validate the Mcp-Method and Mcp-Name headers: Clients now send them so gateways can route without cracking open the request body, and your server has to check that they match the request.
Change your missing-resource error: Use the standard JSON-RPC invalid-params code, -32602, instead of MCP’s own -32002.
Rework your server-initiated requests: Roots, Sampling, and Elicitation no longer call back to the client. Instead, your server returns a result that the client uses to make a follow-up request, which is the biggest rewrite on this list.
Move off the experimental Tasks API: Tasks have graduated from the core spec to an extension and have gained a new lifecycle along the way.

Roots, Sampling, and Logging all entered formal deprecation, and all three keep working for now. The spec also adopted a deprecation policy promising at least a year’s notice before anything is removed, with a 90-day floor reserved for active security risks. That’s more warning than this ecosystem has offered before.

Authorization also hardened, picking up issuer validation and issuer-bound credentials on top of its OAuth 2.0 foundation.

Extensions, which existed before without any process around them, finally got one: namespaced identities and independent release cycles. That’s what let Tasks move out of the core without dragging the whole protocol along, and MCP Apps now arrives as an official extension under that process. A server can send interactive HTML that the host renders in a sandboxed iframe, so a tool call returns a real interface instead of a wall of text.

Treat third-party MCP servers with the same scrutiny you’d give any dependency. The official registry verifies who published a server through GitHub or DNS ownership, but there’s still no code-signing requirement and no review of what a server actually does, and a server you install gets to describe its own tools to your agent.

The Python SDK Renames FastMCP

The spec is only part of the story if you write Python. The MCP Python SDK reached 2.0.0 alongside it, and pip install mcp now provides the 2.x line.

The first change you’ll notice is a rename. FastMCP is now MCPServer, with no alias and no deprecation shim:

# Before, on mcp 1.x
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Demo")

# After, on mcp 2.x
from mcp.server.mcpserver import MCPServer

mcp = MCPServer("Demo")

The rest of 2.0 is broader than the rename suggests:

Wire types are snake_case now: result.isError is now result.is_error, and tool.inputSchema is now tool.input_schema. These types have also moved into a separate mcp-types package, although mcp.types stays as a permanent alias.
One Client replaces three layers: The old arrangement of a transport, a ClientSession, and an initialize() call now collapses into a single object that connects to a URL, a stdio subprocess, or an in-memory server object for tests.
httpx is now httpx2: The SDK moved to the next-generation HTTP client, which is worth knowing if you pin httpx elsewhere in your dependency tree.
Synchronous handlers run on worker threads: They no longer block the event loop. Your handler code doesn’t change, but asyncio.get_running_loop() now raises inside them.
McpError is now MCPError: It’s the same acronym capitalization as MCPServer, so any except McpError clause needs the new spelling.

One MCPServer serves both protocol eras, so 2025-era clients keep working against a migrated server with nothing to configure. The 1.x line moves to maintenance mode with security fixes only, so if you’re not ready this month, then pin mcp>=1.28,<2 and come back to it.

Read the full article at https://realpython.com/python-news-august-2026/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Bypassing the GIL for Parallel Processing in Python

2026-08-03T12:00:00+00:00

In this quiz, you’ll test your understanding of Bypassing the GIL for Parallel Processing in Python.

The global interpreter lock stops your threads from executing Python bytecode at the same time, which caps the speed of CPU-bound code no matter how many cores you have on hand.

By working through this quiz, you’ll revisit how CPU-bound and I/O-bound tasks differ, how process-based parallelism sidesteps the lock entirely, and which strategies finally let your threads spread across every core.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #305: Should You Understand Your Entire Python Codebase?

2026-07-31T12:00:00+00:00

Should you understand the entirety of your codebase? How familiar are you with Python's built-in functions? Christopher Trudeau is back on the show this week with another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: 11 Beginner Tips for Learning Python Programming

2026-07-31T12:00:00+00:00

Test your understanding of 11 Beginner Tips for Learning Python Programming.

You’ll revisit the habits that make new concepts stick, the people and communities that speed up your progress, and the projects that turn what you know into what you can build.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: NumPy Tutorial: Your First Steps Into Data Science in Python

2026-07-30T12:00:00+00:00

In this quiz, you’ll test your understanding of NumPy Tutorial: Your First Steps Into Data Science in Python.

By working through these questions, you’ll revisit how NumPy arrays work, including axes, broadcasting, indexing, Boolean masks, and data types. These are the building blocks that most of Python’s data science ecosystem relies on.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

CrewAI in Python: Coordinating Teams of AI Agents

2026-07-29T14:00:00+00:00

Have you ever asked ChatGPT to research something, analyze the findings, and then write a polished report, all in one prompt? You probably got something back, but it wasn’t great. That’s because you’re asking a single model to wear way too many hats at once. CrewAI is a Python framework that solves this by letting you build a crew of specialized AI agents, each focusing on one part of the job.

For example, instead of cramming research, validation, and writing into a single prompt, you create a team. One agent researches, another validates, and a third writes. Each focuses on what it does best, working together to complete the task.

By the end of this tutorial, you’ll understand that:

CrewAI coordinates teams where each agent has a specific role, goal, and backstory that influence its behavior.
Sequential workflows automatically pass outputs from one agent to the next, making coordinated pipelines straightforward.
The context parameter gives you fine-grained control over which task outputs feed into other tasks.
You can equip agents with tools like web scraping to expand what they can do beyond text generation.
API costs multiply quickly since each agent makes separate LLM calls, and verbose logging helps you debug agent behavior.

Before you invest time learning CrewAI, you should understand when it’s the right tool for your project. This comparison highlights the key trade-offs:

Use Case	Pick CrewAI	Pick LangGraph	Pick AG2 / AutoGen
You need structured, role-based workflows	✅	-	-
You want minimal boilerplate to go from prototype to production	✅	-	-
You need complex state machines with conditional branching	-	✅	-
Your agents need conversational, chat-driven coordination	-	-	✅

CrewAI’s sweet spot is workflows where agents have clear responsibilities and work in a predictable sequence. If you need fine-grained state management with branching logic, LangGraph gives you more control. If your agents need conversational back-and-forth, AG2—the community fork of AutoGen—supports chat-driven coordination patterns and may be a better fit.

Microsoft AutoGen is now in maintenance mode, so new projects typically choose AG2 or Microsoft Agent Framework.

Get Your Code: Click here to download the free sample code you’ll use to build and coordinate teams of AI agents with CrewAI in Python.

Take the Quiz: Test your knowledge with our interactive “CrewAI in Python: Coordinating Teams of AI Agents” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

CrewAI in Python: Coordinating Teams of AI Agents

Check your understanding of CrewAI in Python. Review how to define agent roles, assign tasks, add tools, and coordinate multi-agent workflows.

Get Started With CrewAI in Python

Before you dive into building multi-agent systems with CrewAI, you’ll need to install it and set up an API key for your chosen language model provider. This tutorial uses Google’s Gemini model, which you can access for free through Google AI Studio.

Note: CrewAI is model-agnostic, so you’re not locked into Gemini. It also works with OpenAI, Anthropic’s Claude, Mistral, Groq, and Ollama for local models, among others. Check the CrewAI documentation for the full list of supported providers.

You can install CrewAI from PyPI using pip. Before running the command below, you should create and activate a virtual environment. CrewAI requires Python 3.10 to 3.13, so run python --version first—installing on Python 3.14 or later will silently resolve to a much older CrewAI release and then fail to build:

$ python -m pip install 'crewai[tools,google-genai]'

This installs CrewAI’s core framework, the native Google Gemini provider, and prebuilt tools like web scraping that agents can use during their work.

You’ll need a Gemini API key to run the examples in this tutorial. If you don’t have one yet, then head over to Google AI Studio to sign in with your Google account and generate an API key for free.

Once you have your API key, set it as an environment variable:

PS> $ENV:GEMINI_API_KEY = "your-gemini-api-key-here"

$ export GEMINI_API_KEY="your-gemini-api-key-here"

With your environment variable set, CrewAI is ready to connect to Gemini in your projects.

To get started with CrewAI, you can create a single agent that acts as a travel advisor:

Read the full article at https://realpython.com/crewai-python/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Managing Imports With Python's all

2026-07-28T14:00:00+00:00

Python has something called wildcard imports, which look like from module import *. This type of import allows you to quickly get all the objects from a module into your namespace. However, using this import on a package can be confusing because it’s not clear what you want to import: subpackages, modules, objects? Python has the __all__ variable to work around this issue.

The __all__ variable is a list of strings where each string represents the name of a variable, function, class, or module that you want to expose to wildcard imports.

In this video course, you’ll:

Understand wildcard imports in Python
Use __all__ to control the modules that you expose to wildcard imports
Control the names that you expose in modules and packages
Explore other use cases of the __all__ variable
Learn some benefits and best practices of using __all__

To get the most out of this course, you should be familiar with a few Python concepts, including modules and packages, and the import system.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Managing Imports With Python's all

2026-07-28T12:00:00+00:00

In this quiz, you’ll test your understanding of Managing Imports With Python’s __all__.

By working through this quiz, you’ll revisit how wildcard imports work, what role the __all__ variable plays in modules and packages, and how to define a clean public API for your Python code.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

How to Use Google's Antigravity CLI for AI Code Assistance

2026-07-27T14:00:00+00:00

Antigravity CLI is a terminal-based AI coding tool that brings Google’s agent assistance into your workflow. After installing it and signing in with your Google account, you can ask questions about your code, add new features, track down bugs, and even dispatch multiple subagents to work on separate tasks in parallel, all without leaving your shell:

Antigravity CLI

Antigravity CLI replaced Gemini CLI, which Google retired in June 2026. If you’ve used Gemini CLI, then a lot of this will feel familiar. Your skills, hooks, subagents, and plugins carry over, and the tool still reads its configuration from ~/.gemini/.

You don’t need any of that history to follow along, though. This is a hands-on guide to using Antigravity CLI, not a migration manual. But if you’re switching, then the Coming From Gemini CLI? section rounds up what changed and what to watch out for.

You’re about to install Antigravity CLI, sign in with your Google account, and put it to work on a Python project. It’ll read an unfamiliar module, review it against your conventions, and refactor the code while the agent verifies its own work.

Take the Quiz: Test your knowledge with our interactive “How to Use Google's Antigravity CLI for AI Code Assistance” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Use Google's Antigravity CLI for AI Code Assistance

Test your knowledge of Google's Antigravity CLI, a terminal-based AI coding agent, and how to use it to read, review, and refactor Python code.

Prerequisites

To follow along with this tutorial, you’ll need the following:

Google Account: A Google account lets you sign in to Antigravity CLI. A free account is enough to finish this tutorial, although the free tier’s usage limits are tight and have shifted since launch, so expect to bump into them on longer sessions.
Python 3.12 or higher: You’ll work with a small Python command-line application. If you haven’t already, install Python, making sure the minimum version is Python 3.12.

Because Antigravity CLI is a command-line tool, you should feel comfortable navigating your terminal and running basic shell commands. The tool ships as a single binary for macOS, Linux, and Windows, so any of these platforms will work. Unlike Gemini CLI, it doesn’t depend on Node.js, which means there’s no separate runtime to install first.

Go ahead and download the supporting materials for the Python project you’ll work with throughout this tutorial:

Get Your Code: Click here to download the free sample code you’ll use to follow along as Antigravity CLI reads, reviews, and refactors a small Python command-line tool.

Once you’ve extracted the files, you’ll find an expense-report/ directory with a tiny command-line tool that reads a CSV of transactions and prints a per-category spending summary. To get the most out of this tutorial, initialize a new Git repository in that directory and make an initial commit so you have a clean baseline to diff against later:

$ cd expense-report/
$ git init
$ git add .
$ git commit -m "Initial commit"

This project is the kind of small, undocumented script you might inherit from a teammate, which makes it a good testing ground for Antigravity CLI’s code-reading and refactoring features.

Step 1: Install and Set Up Antigravity CLI

Before you can use Antigravity CLI, you need to install it and sign in with your Google account. In this step, you’ll run the official installer, verify the freshly installed agy command, authenticate, and pick a capable model.

Install the Binary

Antigravity CLI is distributed as a self-contained binary file that ships with the entire Go runtime, so you can download and install it using a single command. Here’s how you can run the official installer script for your platform:

PS> irm https://antigravity.google/cli/install.ps1 | iex

$ curl -fsSL https://antigravity.google/cli/install.sh | bash

The installer places the agy executable in a local bin/ directory, which is ~/.local/bin/ on macOS and Linux. As part of the same run, the installer’s setup step also tries to wire up your PATH and shell profile for you.

Open a new terminal session, or reload your shell profile, and then confirm that the installation worked by checking the version:

$ agy --version
1.0.12

If you see a version number, then you’re ready to authenticate. Because it’s a single Go binary, Antigravity CLI updates itself in place whenever a newer release is available. But you can trigger that manually at any time with agy update.

Read the full article at https://realpython.com/antigravity-cli/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #304: Configuring a Versatile LLM Harness & Scraping the Web With Scrapy

2026-07-24T12:00:00+00:00

Which is more important, the model or the "harness" around an LLM? What are ways to assemble an efficient agentic developer workflow? This week on the show, Ayan Pahwa joins us to discuss harnessing, web scraping, and self-hosting Python applications.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Tool-Agnostic Python Lock Files With PEP 751 and pylock.toml

2026-07-22T14:00:00+00:00

The Python lock file, pylock.toml, records exact dependencies your project needs so installs come out the same every time. It isn’t the first of its kind, though—most modern package tools already define their own lock formats. This has led to a fragmented landscape where reproducibility is often limited to a single tool’s workflow, with each ecosystem effectively speaking its own lock file dialect.

From this fragmentation comes a shared standard: pylock.toml. Defined in PEP 751, pylock.toml standardizes reproducible dependency management across different tools, eliminating vendor lock-in and fragmented requirements.txt workflows. Its purpose is to capture a fully resolved set of dependencies in a format that every tool can understand.

But doesn’t requirements.txt already do this? Not exactly. requirements.txt isn’t so much a standardized specification as an implementation detail of pip. The Requirements File Format specifies that “requirements files serve as a list of items to be installed by pip, when using pip install.”

Still, both files exist to enumerate dependencies that should end up in an environment. The difference lies in how that information is represented, either as tool-specific instructions or as a structured, tool-agnostic record of a resolved state:

If you…	`pylock.toml`	`requirements.txt`
Want to share a single lock file with teammates who use different tools (`uv`, `pip`, `pdm`)	✅	—
Need reproducible, hash-verified installs in CI	✅	—
Want to install without resolving dependencies on the machine	✅	—
Need to pass `pip` flags like `--index-url` or `--no-deps` from the file	—	✅
Want to jot down a couple of dependencies for a quick script by hand	—	✅

This means pylock.toml is the better choice when you care about reproducibility across tools, the integrity of installed artifacts, or a single shared source of truth that can be consumed in different workflows. It’s especially useful in team settings or continuous integration (CI) pipelines where consistency matters more than manual control.

In contrast, requirements.txt remains a good fit for lightweight workflows, quick experiments, or cases where direct control over pip behavior and flags is more important than cross-tool interoperability or strict locking guarantees.

Get Your Code: Click here to download the free sample code you’ll use to generate, inspect, and reuse pylock.toml lock files across pip, uv, and pdm.

Take the Quiz: Test your knowledge with our interactive “Tool-Agnostic Python Lock Files With PEP 751 and pylock.toml” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Tool-Agnostic Python Lock Files With PEP 751 and pylock.toml

Test your understanding of Python lock files and PEP 751, from generating a pylock.toml with pip to installing it across uv and pdm.

Generating a Python Lock File With `pip`

With pip version 25.1 or newer, you can generate a pylock.toml file from a requirements.txt file using the experimental pip lock command. At its core, the pylock.toml will serve as a snapshot of every dependency pip would install.

Before you can use pip lock, you’ll need to define a small set of explicit dependencies in a standard requirements file:

pandas
scipy

This file expresses only the top-level packages to be installed in your environment. It doesn’t describe how pip resolves those packages or what additional dependencies they need to work.

From here, you can have pip produce a fully resolved lock file:

$ python -m pip lock --requirement requirements.txt
WARNING: pip lock is currently an experimental command. It may be
⮑ removed/changed in a future release without prior warning.
Collecting pandas (from -r requirements.txt)
  Downloading pandas-3.0.2-cp314-cp314-manylinux_2_24_x86_64...
Collecting scipy (from -r requirements.txt)
  Downloading scipy-1.17.1-cp314-cp314-manylinux_2_27_x86_64...
Collecting numpy>=2.3.3 (from pandas->-r requirements.txt)
  Downloading numpy-2.4.4-cp314-cp314-manylinux_2_27_x86_64...
Collecting python-dateutil>=2.8.2 (from pandas->-r requirements.txt)
  Downloading python_dateutil-2.9.0.post0-py2.py3-none-any...
Collecting six>=1.5 (from python-dateutil>=2.8.2->pandas->-r requirements.txt)
  Downloading six-1.17.0-py2.py3-none-any.whl.metadata (1.7 kB)

This triggers the resolution process. pip builds a complete dependency graph starting from the explicit packages (pandas, scipy), resolves all required transitive dependencies, and downloads compatible versions for the current Python environment and platform.

This means the result contains both:

Explicit dependencies: What you specified directly, like pandas and scipy
Transitive dependencies: What those packages require to function, like numpy

You can explore that split for yourself in the interactive graph below. Start with only pandas declared to see the full set it resolves to, then toggle scipy on and watch your two requested packages expand into a larger set of pinned dependencies:

Pay attention to numpy as you toggle scipy on and off. The install log above attributes numpy to pandas, but scipy depends on it too, so the resolver doesn’t lock it twice—it records a single, shared numpy entry that satisfies both. That’s exactly what a lock file does for you: it turns the short list of packages you asked for into the complete, deduplicated set that will actually be installed.

By capturing the complete dependency graph, pylock.toml enables reproducible and verifiable installations across environments.

Read the full article at https://realpython.com/python-lock-file-pylock-toml/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: FastAPI: Python API Development With Light Speed

2026-07-22T12:00:00+00:00

Learn FastAPI from the ground up. Build REST APIs, serve web pages with Jinja2 templates, and create a complete URL shortener project in Python.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Exploring Python's Built-in Functions

2026-07-21T14:00:00+00:00

Python’s built-in functions are predefined functions you can use anywhere in your code without any imports. They handle common tasks across math, data type creation, iterable processing, and input and output. Knowing which ones to reach for makes your code shorter and more Pythonic.

In this video course, you’ll:

Recognize Python’s built-in functions and the built-in scope they live in
Use the right built-in for tasks involving math, data types, iterables, and I/O
Distinguish real functions from classes that only look like them
Apply built-ins to solve practical problems with less code you have to write yourself

To get the most out of this video course, you’ll need to be familiar with Python programming, including topics like working with built-in data types, functions, classes, decorators, scopes, and the import system.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Using NumPy reshape() to Change the Shape of an Array

2026-07-20T14:00:00+00:00

The main data structure you’ll use in NumPy, Python’s core library for numerical computing, is the N-dimensional array. Sometimes you need to reorganize the values in a NumPy array into a different layout. That’s what NumPy’s reshape() is for. It changes an array’s shape without changing its data, so you can fit the same values into whatever configuration your program needs.

By the end of this tutorial, you’ll understand that:

You reshape a NumPy array by passing a compatible shape to .reshape(), which rearranges the data without changing its values.
A new shape is compatible only when its total number of elements matches the original array.
reshape() can add or remove dimensions, so the new array doesn’t need the same number of dimensions as the original.
The order parameter sets whether the data is read in row-major ("C") or column-major ("F") order.
Passing -1 for one dimension lets reshape() infer that dimension’s length automatically.

The shape of an array describes the number of dimensions in the array and the length of each dimension. In this tutorial, you’ll learn how to reshape a NumPy array to place all its data in a different configuration. When you complete this tutorial, you’ll be able to alter the shape of any array to suit your application’s needs.

For this tutorial, you should be familiar with the basics of NumPy and N-dimensional arrays. You can read NumPy Tutorial: Your First Steps Into Data Science in Python to learn more about NumPy before diving in.

Supplemental Material: Click here to download the supporting materials that you’ll use with NumPy reshape().

Take the Quiz: Test your knowledge with our interactive “Using NumPy reshape() to Change the Shape of an Array” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Using NumPy reshape() to Change the Shape of an Array

Practice NumPy reshape() by changing an array's shape, adding or removing dimensions, and controlling how the data gets rearranged.

Install NumPy

You’ll need to install NumPy to your environment to run the code in this tutorial and explore reshape(). You can install the package using pip within a virtual environment. Select either the Windows or Linux + macOS tab below to see instructions for your operating system:

PS> python -m venv venv
PS> .\venv\Scripts\activate
(venv) PS> python -m pip install numpy

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install numpy

It’s a convention to use the alias np when you import NumPy. To get started, you can import NumPy in the Python REPL:

>>> import numpy as np

Now that you’ve installed NumPy and imported the package in a REPL environment, you’re ready to start working with NumPy arrays.

Understand the Shape of NumPy Arrays

You’ll use NumPy’s ndarray in this tutorial. In this section, you’ll review the key features of this data structure, including an array’s overall shape and number of dimensions.

You can create an array from a list of lists:

>>> import numpy as np
>>> numbers = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
>>> numbers
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

The function np.array() returns an object of type np.ndarray. This data structure is the main data type in NumPy.

You can describe the shape of an array using the length of each dimension of the array. NumPy represents this as a tuple of integers. The array numbers has two rows and four columns. Therefore, this array has a (2, 4) shape:

>>> numbers.shape
(2, 4)

You can represent the same data using a different shape:

Both of these arrays contain the same data. The array with the shape (2, 4) has two rows and four columns, and the array with the shape (4, 2) has four rows and two columns. You can check the number of dimensions of an array using .ndim:

>>> numbers.ndim
2

Read the full article at https://realpython.com/numpy-reshape/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #303: Free-Threaded Python's History & uv in Production

2026-07-17T12:00:00+00:00

How many attempts have been made to remove Python's Global Interpreter Lock (GIL)? How do they compare to the current approach? Christopher Trudeau is back on the show this week with another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

How to Write a CLAUDE.md File for Claude Code

2026-07-15T14:00:00+00:00

In this tutorial, you’ll write CLAUDE.md files for Claude Code that capture your Python workflow, project commands, and coding rules. You’ll create a global file for personal defaults, a project-level file for repository guidance, and one for local notes that shouldn’t be committed to version control.

To make these ideas concrete, you’ll work through a realistic example: steering Claude Code away from incorrect suggestions for AWS Bedrock global cross-region inference. You’ll turn that recurring correction into CLAUDE.md guidance and learn how to apply the same pattern to your project-specific rules, commands, and preferences that matter in your own codebase:

Claude Code Making Changes With Access to CLAUDE.md Instructions

A good CLAUDE.md file doesn’t document everything about your project. Instead, it records commands, constraints, and workflow preferences that Claude Code can’t easily infer from the repository. The aim is to prevent repeated corrections. You’re not trying to teach Claude Code every detail of Python or your codebase.

You can always use the /init command as a starting point, but recent research found that unnecessarily large and redundant context files often hurt agent performance and recommended keeping them minimal. This means the auto-generated CLAUDE.md should usually be trimmed as it tends to repeat what Claude Code can already discover from the repo and can waste tokens without gain.

With that in mind, you can now build your CLAUDE.md files: first your global defaults, then the project-specific rules, and finally any local notes you may have. Before you start writing, review the prerequisites below to prepare your environment to follow along.

Get Your Cheat Sheet: Click here to download a free PDF summarizing the patterns, pitfalls, and prompts for writing CLAUDE.md files that steer Claude Code through your Python projects.

Take the Quiz: Test your knowledge with our interactive “How to Write a CLAUDE.md File for Claude Code” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Write a CLAUDE.md File for Claude Code

Practice writing CLAUDE.md files for Claude Code across global, project, and local layers that capture your Python commands and conventions.

Prerequisites

To follow along, you’ll need Claude Code installed and configured, a text editor for creating Markdown files, plus a Python project or script that you can safely modify. You should also be familiar with how that project handles dependencies, tests, and any linting or formatting it uses.

A concrete Python project or script makes this tutorial more useful. If you don’t already have one, then you can download the sample script below before continuing:

Get Your Code: Click here to download the free sample code you’ll use to follow along as you write CLAUDE.md rules that steer Claude Code toward correct AWS Bedrock cross-region inference.

The example Python script uses AWS Bedrock with boto3, which requires Python 3.10 or higher. It also relies on configured AWS CLI credentials to generate output. That said, you don’t have to run the script to follow along. It’s enough to read the prompt and Claude’s responses. Set up AWS only if you want to run it and play with it yourself.

Later on in the tutorial, you’ll see a Bedrock-specific mistake made by Claude regarding the proper way to enable global cross-region inference for AWS Bedrock models. It’s a mistake where the code produced still works but isn’t entirely correct or what you intended. This type of error generalizes to any quirks or project-specific conventions in your own Python project or repo.

Step 1: Audit Claude Code’s Mistakes

Start by observing where Claude actually needs guidance. Don’t write CLAUDE.md from a long list of your favorite Python rules, as that’s mostly unnecessary context. Run Claude Code on a small task in your project and watch for the repeated mistakes it makes.

A short audit can often give you better instructions than a long checklist of rules or directives you think Claude Code needs. Try using this workflow before creating any instruction file for Claude Code:

Temporarily move existing global and project-level CLAUDE.md and CLAUDE.local.md files out of the way. You can rename them or move them out of their respective directories so Claude Code doesn’t pick them up. You can verify Claude Code hasn’t loaded them with the /memory command.
Ask Claude Code to make a small change to your project.
Record each correction you have to give.
Sort each correction into global, project-level, or local guidance.

Look for knowledge that Claude Code can’t readily and reliably infer from reading your codebase. Build commands, test commands, environment variables, and team conventions are good starting points. Standard Python advice—apart from preferred defaults Claude may not follow—usually isn’t necessary because Anthropic models are already proficient at writing Python code, and such advice generally wastes tokens in a CLAUDE.md file.

Note: What does readily mean in this context? If Claude has to read numerous source code files to figure out how to run the project or understand a particular repo convention, this is typically not considered to be “readily” discoverable and could warrant a line in CLAUDE.md.

It can still be beneficial to add your preferred Python defaults to CLAUDE.md, but they should only be a small part of it.

When auditing, note the correction, the scope, and the instruction you want Claude Code to follow. For example, you might notice the following corrections in a typical Python repo:

Repeated Correction	Better Instruction	Scope
Claude Code installed packages imperatively with `pip` `install`	Add project dependencies with `uv add`; use `uv pip install` only for ad hoc env installs	Global or project
Claude Code skipped the test command	Run `uv run pytest` before finishing a task	Project
Claude Code added `print()` debugging	Use the configured logger	Project
Claude Code edited or created unrelated files	Touch only files needed for the task	Global
Claude Code opened broad files too early	Use `rg` to find relevant files before opening source files	Global

While doing this exercise, use the following flowchart to decide when and where to add a rule:

Read the full article at https://realpython.com/python-claude-md/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Understanding Mixin Classes in Python

2026-07-14T14:00:00+00:00

Mixins offer a powerful way to reuse code across multiple Python classes without forcing them into a rigid inheritance hierarchy. Instead of building deep and brittle class trees, you can use mixins to share common behaviors in a modular and flexible way. Learn when and how to implement mixin classes effectively in your Python projects.

By the end of this video course, you’ll understand that:

Mixins allow you to add isolated, reusable functionalities to classes without enforcing a strict type hierarchy.
Python has no dedicated syntax for declaring mixins. You create mixins by defining classes with specific behaviors that other classes can inherit without forming an is-a relationship.
Mixins rely on multiple inheritance to combine features from different classes, enhancing flexibility and code reuse.
Stateful mixins require careful design to manage instance attributes and avoid conflicts with other classes.
Python’s method resolution order (MRO) determines the order in which classes are inherited, affecting how mixins are applied.

To get the most out of this video course, you should have a good understanding of object-oriented programming (OOP), SOLID principles, inheritance, and Python classes.

So, what is a Python mixin, and when should you use one?

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

LangGraph Tutorial: Build Stateful AI Agents in Python

2026-07-13T14:00:00+00:00

LangGraph is a versatile Python framework designed for stateful, cyclic, and multi-actor Large Language Model (LLM) applications. LangGraph builds upon its parent library, LangChain, and allows you to build sophisticated workflows that can handle the complexities of real-world LLM applications. Throughout this LangGraph tutorial, you’ll build a complete email-processing agent from the ground up.

By the end of this tutorial, you’ll understand that:

You can use LangGraph to build LLM workflows by defining state graphs with nodes and edges.
LangGraph expands LangChain’s capabilities by providing tools to build complex LLM workflows with state, conditional edges, and cycles.
LLM agents in LangGraph autonomously process tasks using state graphs to make decisions and interact with tools or APIs.
You can use LangGraph independently of LangChain, although they’re often used together to complement each other.

Explore the full tutorial to gain hands-on experience with LangGraph, including setting up workflows and building a LangGraph agent that can autonomously parse emails, send emails, and interact with API services.

While you’ll get a brief primer on LangChain in this tutorial, you’ll benefit from having prior knowledge of LangChain fundamentals. You’ll also want to ensure you have intermediate Python knowledge, specifically in object-oriented programming concepts like classes and methods.

Get Your Code: Click here to download the free sample code that you’ll use to build stateful AI agents with LangGraph in Python.

Take the Quiz: Test your knowledge with our interactive “LangGraph: Build Stateful AI Agents in Python” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

LangGraph: Build Stateful AI Agents in Python

Test your understanding of LangGraph, the Python library for building stateful, cyclic, and multi-actor LLM workflows and agents built on LangChain.

What Is LangGraph?

LangGraph is an open-source Python framework for building stateful, cyclic, and multi-agent applications powered by large language models (LLMs). It gives you a low-level orchestration layer that represents an LLM application as a graph: each step is a node, and the connections between steps are edges. Because the graph can branch and loop, you can model decision-making and repeated actions that a simple, linear pipeline can’t express.

LangGraph is part of the LangChain ecosystem and integrates closely with LangChain, but it’s a standalone framework that you can also use on its own.

What is LangGraph used for? It shines whenever an LLM application needs to do more than answer a single prompt, including tasks like:

Stateful workflows that carry information forward from one step to the next
Conditional logic that routes the application down different paths depending on the data
Cycles that repeat a step until some condition is met
AI agents that decide which tools to call and act autonomously
Multi-agent systems in which several agents coordinate to complete a larger task

Throughout this tutorial, you’ll build these capabilities from the ground up as you create an email-processing agent. Before you start coding, you’ll install LangGraph and set up a few example emails to test your work.

Install LangGraph

LangGraph is available on PyPI, and you can install it with pip. Open a terminal or command prompt, create a new virtual environment, and then run the following command:

(venv) $ python -m pip install langgraph

This command will install the latest version of LangGraph from PyPI onto your machine. This tutorial was written for LangGraph 1.2, and the graph-building API that you’ll use here has been stable since the 1.0 long-term support release. To verify that the installation was successful, start a Python REPL and import LangGraph:

>>> import langgraph

If the import runs without error, then you’ve successfully installed LangGraph. You’ll also need a few more libraries for this tutorial:

(venv) $ python -m pip install langchain-openai "pydantic[email]"

You’ll use langchain-openai to interact with OpenAI LLMs, but keep in mind that you can use any LLM provider you like with LangGraph and LangChain. You’ll use pydantic to validate the information your agent parses from emails.

Before moving forward, if you choose to use OpenAI, make sure you’re signed up for an OpenAI account and that you have a valid API key. You’ll need to set the following environment variable before running any examples in this tutorial:

OPENAI_API_KEY=<YOUR-OPENAI-API-KEY>

Note that while LangGraph was made by the creators of LangChain and the two libraries are highly compatible, it’s possible to use LangGraph without LangChain. However, it’s more common to use LangChain and LangGraph together, and you’ll see throughout this tutorial how they complement each other.

With that, you’ve installed all the dependencies you’ll need for this tutorial, and you’re ready to create your LangGraph email processor. Before diving in, you’ll take a brief detour to set up quick sanity tests for your app. Then, you’ll go through an overview of LangChain chains and explore LangGraph’s core concept, the state graph.

Read the full article at https://realpython.com/langgraph-python/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #302: Constructing and Judging Modern Agentic Workflows

2026-07-10T12:00:00+00:00

How can you improve your LLM agent systems through specification enrichment? What are the advantages of having an LLM act as a judge within an agent system? This week on the show, Senior IEEE Member and Quality Engineer Suneet Malhotra joins us to discuss building and evaluating agentic architecture.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

How to Use GitHub

2026-07-08T14:00:00+00:00

When you work on a local Python project, tracking your changes with Git is a great way to maintain a history of your code. However, keeping your repository only on your computer leaves your work vulnerable to hardware failures and makes collaboration difficult. By learning how to use GitHub, you can back up your work, share your code with the public, and work alongside other developers.

By following this guide, you’ll learn how to create a GitHub repository, connect it to your local project, and collaborate with others online.

Here’s a preview of what a successfully connected and active GitHub repository looks like:

The screenshot above is your destination. In the rest of this tutorial, you’ll build that result one step at a time, starting from your local project.

Get Your Code: Click here to download the free sample code you’ll use to follow along as you put a weather CLI app on GitHub and practice core workflows like commits, branches, pull requests, and issues.

Take the Quiz: Test your knowledge with our interactive “How to Use GitHub” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Use GitHub

Practice putting a Python project on GitHub by creating a remote repository, pushing your local code, and collaborating with others.

Prerequisites

This guide is designed for developers who already have a basic understanding of the command line and local version control. To follow along with the steps, you’ll need:

A GitHub account: A free account registered on GitHub.
Git installed: The Git command-line tools installed on your operating system.
A local Git repository: A folder on your computer that contains some files and has been initialized with git init. You should also have at least one saved commit in this local repository.

If you need help setting up your local environment before moving forward, you can review the How to Use Git: A Beginner’s Guide tutorial to get your local repository ready.

If you prefer to learn by watching, Real Python’s Introduction to Git and GitHub for Python video course walks through both tools from the ground up and pairs well with the hands-on steps in this guide.

To work through the steps that follow, you can set up a sample Python project locally. Open your terminal, create a new folder called weather-data-parser, and navigate inside it:

$ mkdir weather-data-parser
$ cd weather-data-parser

Create a new file named weather.py and paste the Python code below into it. This weather app is adapted from Real Python’s Raining Outside? Build a Weather CLI App With Python tutorial, which provides additional background and a full step-by-step walkthrough of the original project.

import argparse
import json
import sys
from configparser import ConfigParser
from urllib import error, parse, request

# =========================
# Styling / Colors
# =========================
PADDING = 20
RED = "\033[1;31m"
BLUE = "\033[1;34m"
CYAN = "\033[1;36m"
GREEN = "\033[0;32m"
YELLOW = "\033[33m"
WHITE = "\033[37m"
REVERSE = "\033[;7m"
RESET = "\033[0m"

def change_color(color):
    print(color, end="")

# =========================
# Weather Config
# =========================
BASE_WEATHER_API_URL = "http://api.openweathermap.org/data/2.5/weather"
# Weather Condition Codes
# https://openweathermap.org/weather-conditions#Weather-Condition-Codes-2
THUNDERSTORM = range(200, 300)
DRIZZLE = range(300, 400)
RAIN = range(500, 600)
SNOW = range(600, 700)
ATMOSPHERE = range(700, 800)
CLEAR = range(800, 801)
CLOUDY = range(801, 900)

def read_user_cli_args():
    """Handles the CLI user interactions.

    Returns:
        argparse.Namespace: Populated namespace object
    """
    parser = argparse.ArgumentParser(
        description="gets weather and temperature information for a city"
    )
    parser.add_argument(
        "city", nargs="+", type=str, help="enter the city name"
    )
    parser.add_argument(
        "-i",
        "--imperial",
        action="store_true",
        help="display the temperature in imperial units",
    )
    return parser.parse_args()

def build_weather_query(city_input, imperial=False):
    """Builds the URL for an API request to OpenWeather's Weather API.

    Args:
        city_input (List[str]): Name of a city as collected by argparse
        imperial (bool): Whether or not to use imperial units for temperature

    Returns:
        str: URL formatted for a call to OpenWeather's city name endpoint
    """
    api_key = _get_api_key()
    city_name = " ".join(city_input)
    url_encoded_city_name = parse.quote_plus(city_name)
    units = "imperial" if imperial else "metric"
    url = (
        f"{BASE_WEATHER_API_URL}?q={url_encoded_city_name}"
        f"&units={units}&appid={api_key}"
    )
    return url

def _get_api_key():
    """Fetch the API key from your configuration file.

    Expects a configuration file named "secrets.ini" with structure:

        [openweather]
        api_key=<YOUR-OPENWEATHER-API-KEY>
    """
    config = ConfigParser()
    config.read("secrets.ini")
    return config["openweather"]["api_key"]

def get_weather_data(query_url):
    """Makes an API request to a URL and returns the data as a Python object.

    Args:
        query_url (str): URL formatted for OpenWeather's city name endpoint

    Returns:
        dict: Weather information for a specific city
    """
    try:
        response = request.urlopen(query_url)
    except error.HTTPError as http_error:
        if http_error.code == 401:  # 401 - Unauthorized
            sys.exit("Access denied. Check your API key.")
        elif http_error.code == 404:  # 404 - Not Found
            sys.exit("Can't find weather data for this city.")
        else:
            sys.exit(f"Something went wrong... ({http_error.code})")
    data = response.read()
    try:
        return json.loads(data)
    except json.JSONDecodeError:
        sys.exit("Couldn't read the server response.")

def display_weather_info(weather_data, imperial=False):
    """Prints formatted weather information about a city.

    Args:
        weather_data (dict): API response from OpenWeather by city name
        imperial (bool): Whether or not to use imperial units for temperature

    More information at https://openweathermap.org/current#name
    """
    city = weather_data["name"]
    weather_id = weather_data["weather"][0]["id"]
    weather_description = weather_data["weather"][0]["description"]
    temperature = weather_data["main"]["temp"]
    change_color(REVERSE)
    print(f"{city:^{PADDING}}", end="")
    change_color(RESET)
    weather_symbol, color = _select_weather_display_params(weather_id)
    change_color(color)
    print(f"\t{weather_symbol}", end=" ")
    print(
        f"\t{weather_description.capitalize():^{PADDING}}",
        end=" ",
    )
    change_color(RESET)
    print(f"({temperature}°{'F' if imperial else 'C'})")

def _select_weather_display_params(weather_id):
    """Selects a weather symbol and a display color for a weather state.

    Args:
        weather_id (int): Weather condition code from the OpenWeather API

    Returns:
        tuple[str]: Contains a weather symbol and a display color
    """
    if weather_id in THUNDERSTORM:
        display_params = ("💥", RED)
    elif weather_id in DRIZZLE:
        display_params = ("💧", CYAN)
    elif weather_id in RAIN:
        display_params = ("💦", BLUE)
    elif weather_id in SNOW:
        display_params = ("⛄️", WHITE)
    elif weather_id in ATMOSPHERE:
        display_params = ("🌀", BLUE)
    elif weather_id in CLEAR:
        display_params = ("🔆", YELLOW)
    elif weather_id in CLOUDY:
        display_params = ("💨", WHITE)
    else:  # In case the API adds new weather codes
        display_params = ("🌈", RESET)
    return display_params

if __name__ == "__main__":
    user_args = read_user_cli_args()
    query_url = build_weather_query(user_args.city, user_args.imperial)
    weather_data = get_weather_data(query_url)
    display_weather_info(weather_data, user_args.imperial)

Because this is a Python project, it’s best practice to include a .gitignore file to avoid accidentally uploading sensitive information like API keys or unnecessary files like __pycache__ directories to GitHub. Create a file named .gitignore and add the following lines:

__pycache__/
secrets.ini

Now initialize the Git repository:

$ git init

Before making your first commit, it’s often helpful to check what files Git is tracking and what changes will be included. You can do this with the git status command:

$ git status

This command shows the current state of your working directory, including any new or modified files that will be part of the next commit. At this point, you should see your project files, including weather.py and .gitignore, listed as untracked files:

On branch master

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        .gitignore
        weather.py

nothing added to commit but untracked files present (use "git add" to track)

You can now stage your files and create the initial commit:

Read the full article at https://realpython.com/how-to-use-github/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Testing MCP Servers With a Python MCP Client

2026-07-07T14:00:00+00:00

Building an MCP client in Python is a great way to test MCP servers directly from your terminal. In this video course, you’ll build a minimal MCP client for the command line. It can connect to an MCP server through the standard input/output (stdio) transport, list the server’s capabilities, and interact with the server’s tools, prompts, and resources directly and deterministically.

By the end of this course, you’ll understand that:

You can build an MCP client app for the command line using the MCP Python SDK.
You can connect a client to an MCP server through the stdio transport and point it at any server from the command line.
You can list a server’s capabilities by calling .list_tools(), .list_prompts(), and .list_resources() on a ClientSession instance.
You can call tools, get prompts, and fetch resources from an MCP server through dedicated CLI subcommands.

Next, you’ll move through setup, client structure, server connection, and capability discovery to test MCP servers from your terminal.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #301: Running Python Locally in a Sandbox

2026-07-03T12:00:00+00:00

How do you avoid the risk of running a Python application locally that could be malicious, break your code, or leak private data? How can you create a sandboxed local environment using WASM and MicroPython? Christopher Trudeau is back on the show this week with another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Managing and Measuring Python Code Quality

2026-06-30T14:00:00+00:00

Producing high-quality Python code involves using appropriate tools and consistently applying best practices. High-quality code is functional, readable, maintainable, efficient, and secure. It adheres to established standards and has excellent documentation.

You can achieve these qualities by following best practices such as descriptive naming, consistent coding style, modular design, and robust error handling. To help you with all this, you can use tools such as linters, formatters, and profilers.

By the end of this course, you’ll understand that:

Checking the quality of Python code involves using tools like linters and static type checkers to ensure adherence to coding standards and detect potential errors.
Writing quality code in Python requires following best practices, such as clear naming conventions, modular design, and comprehensive testing.
Good Python code is characterized by readability, maintainability, efficiency, and adherence to standards like PEP 8.
Making Python code look good involves using formatters to ensure consistent styling and readability, aligning with established coding styles.
Making Python code readable means using descriptive names for variables, functions, classes, modules, and packages.

Enjoy working through this course as you learn more about the strategies, tools, and best practices that will help you write high-quality Python code.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #300: Maintaining Your Python Developer Instincts While Using LLM Tools

2026-06-26T12:00:00+00:00

Do you feel like your Python skills are atrophying after using LLM coding tools? How do you add the right kind of friction into your coding routine to keep your developer instincts sharp? Christopher Trudeau is back on the show this week with another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Using LlamaIndex for RAG in Python

2026-06-23T14:00:00+00:00

Discover how to use LlamaIndex with practical examples. This framework helps you build retrieval-augmented generation (RAG) apps using Python. LlamaIndex lets you load your data and documents, create and persist searchable indexes, and query an LLM using your data as context.

In this course, you’ll learn the basics of installing the package, setting AI providers, spinning up a query engine, and running queries against remote or local models.

By the end of this course, you’ll understand that:

You use LlamaIndex to connect your data to LLMs, allowing you to build AI agents, workflows, query engines, and chat engines.
You can perform RAG with LlamaIndex to retrieve relevant context at query time, helping the LLM generate grounded answers and minimize hallucinations.

You’ll start by preparing your environment and installing LlamaIndex. From there, you’ll learn how to load your own files, build and save an index, choose different AI providers, and run targeted queries over your data through a query engine.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Building Python Skills for the Job Market

2026-06-16T14:00:00+00:00

When you’re learning Python, the sheer volume of topics to explore can feel overwhelming because there’s so much you could focus on. Should you dive into web frameworks before exploring data science? Is test-driven development something you need right away? And which skills actually matter to employers in the age of AI-assisted software development?

By the end of this course, you’ll have:

A clear understanding of which Python skills employers consistently look for
A personalized Python developer roadmap showing where you are and where you need to go
A weekly practice plan that makes consistent progress feel achievable

Python itself is relatively beginner-friendly, but its versatility makes it easy to wander without direction. Without a clear plan, you can spend months studying topics that won’t help you land your first developer job.

This course will show you how to build a focused learning strategy that aligns with real job market demands. You’ll learn how to research what employers value, assess your current strengths and gaps, and structure a practice routine that turns scattered study sessions into steady progress.

Instead of guessing what to learn next, you’ll have a concrete document that shows you exactly where to focus:

Work through this course to identify the skills you need and set yourself up for success.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #299: EuroPython 2026: Celebrating 25 Years

2026-06-12T12:00:00+00:00

What's happening at EuroPython 2026? The conference celebrates its 25th anniversary this year in Kraków, Poland. This week on the show, organizers Mia Bajić and Daria Linhart Grudzien join me to discuss this year's conference.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Accessing Multiple AI Models With the OpenRouter API

2026-06-09T14:00:00+00:00

One of the quickest ways to call multiple AI models from a single Python script is to use OpenRouter’s API, which acts as a unified routing layer between your code and multiple AI providers. By the end of this course, you’ll be able to access models from several providers through one unified API.

This convenience matters because the AI ecosystem is highly fragmented: each provider exposes its own API, authentication scheme, rate limits, and model lineup. Working with multiple providers often requires additional setup and integration effort, especially when you want to experiment with different models, compare outputs, or evaluate trade-offs for a specific task.

OpenRouter gives you access to thousands of models from leading providers like OpenAI, Anthropic, Mistral, Google, and Meta. You can switch between them without changing your application code.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #298: Reducing the Size of Python Docker Containers

2026-06-05T12:00:00+00:00

How can you easily reduce the size of a Python Docker container? What are the exceptions you should catch in your code? Christopher Trudeau is back on the show this week with another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #297: Improving Python Through PEPs and Protocols

2026-05-29T12:00:00+00:00

Have you ever been confused by the naming of modules you're importing from a package? Is there a standard way to organize and name your Python virtual environments? This week on the show, Brett Cannon returns to discuss the Python Enhancement Proposals (PEPs) he's been working on recently.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Python Game Development

2026-04-16T12:00:00+00:00

Build Python games from command-line projects to 2D graphical games with turtle, Tkinter, Pygame, and Arcade.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: LLM Application Development With Python

2026-03-19T12:00:00+00:00

Build LLM-powered applications in Python. Call model APIs, craft prompts, add retrieval-augmented generation, create AI agents, and connect via MCP.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Python Coding With AI

2025-12-07T12:00:00+00:00

Use AI coding assistants to write, review, and debug Python code faster. Choose an editor-based assistant like Cursor or a terminal-based one like Claude Code, then make it part of your daily workflow.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Perfect Your Python Development Setup

2024-11-14T12:00:00+00:00

Set up a Python development environment with VS Code, PyCharm, virtual environments, Git, pyenv, Docker, and AI coding tools like Claude Code and Cursor.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Important Standard Library Modules

2024-11-14T12:00:00+00:00

Explore Python standard library modules including math, datetime, JSON, CSV, regex, subprocess, and argparse through hands-on tutorials and courses.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Functions and Scopes

2024-11-14T12:00:00+00:00

Learn to define Python functions, use parameters and return values, create inner functions, and understand namespaces and scope.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Create Graphical User Interfaces (GUI)

2024-11-14T12:00:00+00:00

Build Python GUI applications with Tkinter, PyQt, wxPython, and Kivy. Learn layouts, event handling, threading, and database integration.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Network Programming and Security

2024-11-14T12:00:00+00:00

Learn network programming and security in Python. Work with CRUD operations, REST APIs, HTTPS, and socket programming to build networked apps.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Python Control Flow and Loops

2024-11-14T12:00:00+00:00

Learn Python control flow and loops. Use conditional statements, Boolean operators, for and while loops, and keywords like break and continue.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Real Python

Coding With OpenCode: AI-Assisted Python

Quiz: Coding With OpenCode: AI-Assisted Python

Qt Designer and Python: Build Your GUI Applications Faster

Getting Started With Qt Designer

Installing and Running Qt Designer

The Real Python Podcast – Episode #306: Programmatically Developing LLM Prompts With DSPy

Quiz: How to Use Type Hints for Multiple Return Types in Python

Quiz: Python's Assignment Operator: Write Robust Assignments

Validating Data With Pointblank in Python

Get Started With Pointblank in Python

Quiz: Validating Data With Pointblank in Python

Sending Emails Using Python

Quiz: K-Means Clustering in Python: A Practical Guide

Quiz: Sending Emails Using Python

MCP Gets Its Biggest Rewrite and Other Python News for August 2026

MCP Drops Sessions and Goes Stateless

What the New Spec Changes

The Python SDK Renames FastMCP

Quiz: Bypassing the GIL for Parallel Processing in Python

The Real Python Podcast – Episode #305: Should You Understand Your Entire Python Codebase?

Quiz: 11 Beginner Tips for Learning Python Programming

Quiz: NumPy Tutorial: Your First Steps Into Data Science in Python

CrewAI in Python: Coordinating Teams of AI Agents

Get Started With CrewAI in Python

Managing Imports With Python's __all__

Quiz: Managing Imports With Python's __all__

How to Use Google's Antigravity CLI for AI Code Assistance

Prerequisites

Step 1: Install and Set Up Antigravity CLI

Install the Binary

The Real Python Podcast – Episode #304: Configuring a Versatile LLM Harness & Scraping the Web With Scrapy

Tool-Agnostic Python Lock Files With PEP 751 and pylock.toml

Generating a Python Lock File With pip

Learning Path: FastAPI: Python API Development With Light Speed

Exploring Python's Built-in Functions

Using NumPy reshape() to Change the Shape of an Array

Install NumPy

Understand the Shape of NumPy Arrays

The Real Python Podcast – Episode #303: Free-Threaded Python's History & uv in Production

How to Write a CLAUDE.md File for Claude Code

Prerequisites

Step 1: Audit Claude Code’s Mistakes

Understanding Mixin Classes in Python

LangGraph Tutorial: Build Stateful AI Agents in Python

What Is LangGraph?

Install LangGraph

The Real Python Podcast – Episode #302: Constructing and Judging Modern Agentic Workflows

How to Use GitHub

Prerequisites

Testing MCP Servers With a Python MCP Client

The Real Python Podcast – Episode #301: Running Python Locally in a Sandbox

Managing and Measuring Python Code Quality

The Real Python Podcast – Episode #300: Maintaining Your Python Developer Instincts While Using LLM Tools

Using LlamaIndex for RAG in Python

Building Python Skills for the Job Market

The Real Python Podcast – Episode #299: EuroPython 2026: Celebrating 25 Years

Accessing Multiple AI Models With the OpenRouter API

The Real Python Podcast – Episode #298: Reducing the Size of Python Docker Containers

The Real Python Podcast – Episode #297: Improving Python Through PEPs and Protocols

Learning Path: Python Game Development

Learning Path: LLM Application Development With Python

Learning Path: Python Coding With AI

Learning Path: Perfect Your Python Development Setup

Learning Path: Important Standard Library Modules

Learning Path: Functions and Scopes

Learning Path: Create Graphical User Interfaces (GUI)

Learning Path: Network Programming and Security

Learning Path: Python Control Flow and Loops

Managing Imports With Python's all

Quiz: Managing Imports With Python's all

Generating a Python Lock File With `pip`