Python Friday

#340: Running Scripts With uv run

Fri, 17 Jul 2026 20:00:00 +0200

If we dive into Python scripting or need to share a small utility with a colleague, we quickly run into a familiar problem: Incompatible or missing package versions. We can solve that problem with virtual environments, but that brings us right to the next one. Managing multiple environments for small, standalone scripts is tedious and breaks the workflow.

#339: Parse Markdown Metadata With Frontmatter

Fri, 10 Jul 2026 20:00:00 +0200

Frontmatter is the metadata format for Markdown and YAML that we can use in MkDocs and many other tools. While we could parse the metadata on our own, tools like Python Frontmatter are a much simpler way to do it. Let us see how this works.

#338: Multi-Agents in LangGraph

Fri, 03 Jul 2026 20:00:00 +0200

A multi-agent system is an architecture style where we split a larger task across several specialised agents instead of relying on one LLM call to do everything. Each agent can have its own role, such as planning, researching, validating, or writing the final answer. That way we can build workflows that are easier to control and to extend.

In LangGraph we can build this kind of applications with nodes that represent the agents and let the workflow guide the communication between them. This approach let us reuse most of what we already know about LangGraph while the multi-agents are in control of their subject.

#337: Add a MCP Server to LangGraph

Fri, 26 Jun 2026 20:00:00 +0200

Last week we saw how FastMCP can help us to create a MCP server. In this post we see how we can connect our LangGraph application to an MCP server.

#336: Build a MCP Server With FastMCP

Fri, 19 Jun 2026 20:00:00 +0200

An MCP (Model Context Protocol) server is an open-standard integration that acts as a bridge between Large Language Models and external data sources or tools. That way we can get more specific answers about our data or let the LLM act on our behalf.

We can build our own MCP server with various tools. One of the simplest one for Python is FastMCP, that feels a lot like FastAPI. Let us see what we need to do to run our own tools through a MCP server.

#335: Handle the Raspberry-Test in LangGraph

Fri, 12 Jun 2026 20:00:00 +0200

A common way to test the "quality" of an AI solution is to ask for how many r’s are in the word raspberry. LLMs are notoriously bad in such questions, but that does not mean we have to accept defeat with our AI application. Let us figure out how we can handle these types of tests.

#334: Create Subgraphs in LangGraph

Fri, 05 Jun 2026 20:00:00 +0200

The more complex our applications get, the harder it is to follow along our graph. Luckily for us, there is the concept of subgraphs that let us split our graph into parts that we can reuse.

For this post we create a minimalistic text writing pipeline that puts the quality checks into a subgraph. Let us see how we can do that.

#333: Inspect and Rerun Workflows in LangGraph

Fri, 29 May 2026 20:00:00 +0200

When we switch from our hand-written long-term memory solution in last week's post to a pre-build SqliteSaver, we not only need less code, but we gain new options. One of the benefits of saving the whole state to a database is that we can inspect the current workflow and rerun them after we fixed a problem. Let us see how that works.

#332: Long-Term Memory in LangGraph

Fri, 22 May 2026 20:00:00 +0200

Last week we added short-term memory to our LangGraph application. That works great as long as we stay in the same session. But when we want to keep the memory around between sessions, we need a different approach.

In this post we create our hand-written approach for a long-term memory solution. Do this only to understand what is going on and not to use it in production. For that purpose, we can use pre-build solutions that we explore next week.

#331: Short-Term Memory in LangGraph

Fri, 15 May 2026 20:00:00 +0200

A while back we added a chat history to our LLM client so that we did not need to constantly repeat ourselves. This problem is now back in our LangGraph workflows. Luckily for us, LangGraph has a simple way to add memory to our workflows. Let us see how we can do that.

#330: Selective Approval With LangGraph

Fri, 08 May 2026 20:00:00 +0200

Last week we created a basic LangGraph example for the human-in-the-loop pattern. We ended up with a solution that run our tools but only after we approved the run. While this works, it gets cumbersome in no time. Especially when we have many tools and most of them are safe to use.

In this post we use a policy-based approach that allows us to create a list of safe tools for that we do not need a manual intervention. Let us see how we can build that.

#329: Human in the Loop With LangGraph

Fri, 01 May 2026 20:00:00 +0200

Last week we learned how to build our own tools to use in LangGraph. Sometimes those tools could be dangerous, and we want to approve their usage before they run. For that we can use the Human-in-the-Loop (HITL) pattern.

#328: Create Tools for LangGraph

Fri, 24 Apr 2026 20:00:00 +0200

LangGraph gets interesting as soon as we start to integrate it with our tasks. For that we need custom tools so that the LLM can interact with our data. Let us see how we can create our own tools and use them in LangGraph.

#327: Visualise the Graph in LangGraph

Fri, 17 Apr 2026 20:00:00 +0200

The more complex our control flow in our LangGraph application, the harder it is to understand what is going on. Luckily for us, we have multiple ways to visualise our graphs. Let us find out how we can do that.

#326: Control Flow in LangGraph

Fri, 10 Apr 2026 20:00:00 +0200

Last week, we created a simple LangGraph application as our starting point. In this post, we will look at different ways to manage control flow and how nodes can interact with each other. While this sounds even more boring than our last post, here is where things start to get interesting.

#325: First Steps With LangGraph

Fri, 03 Apr 2026 20:00:00 +0200

Agents in LangChain allow us to use the LLM as a reasoning engine and take actions based on their abilities. We used them successfully with our CSV files or when we queried a database. However, while we get a lot of flexibility, we often wish for a middle ground that gives us not only flexibility, but a bit more control on what is going on.

We can use LangGraph for this purpose. This low-level orchestration framework allows us to build simple agents or direct a large network of independent agents to solve problems for us. Let us get started with the most basic part and add from there.

#324: Add a UI to the Python Friday RAG

Fri, 27 Mar 2026 20:00:00 +0100

While the command line Python Friday RAG is nice, a user interface that looks more like other chatbots would be a nice enhancement. Luckily for us, there are a few tools we can use that do not need much code. Let us see how that can look like.

#323: Add the LLM to the Python Friday RAG

Fri, 20 Mar 2026 20:00:00 +0100

Last week we turned blog posts written in Markdown into embeddings in Chroma. That gives us the data that we need for our Python Friday RAG (Retrieval Augmented Generation). In this post we reuse the LangChain configuration that helped us in various posts to connect our script to a local LLM running inside LM Studio.

#322: Embed Markdown for a Python Friday RAG

Fri, 13 Mar 2026 20:00:00 +0100

After we found with Chroma a flexible vector store, we have everything together to build a RAG (Retrieval Augmented Generation) for the Python Friday blog that uses LangChain and a local LM Studio.

In this post we focus on extracting metadata from the Markdown files I use in this MkDocs Material powered blog. We split the Markdown into useful chunks and turn the metadata for the blog post into a metadata dictionary to use with Chroma. Let us explore how we can do this first part.

#321: Working With Metadata in Chroma

Fri, 06 Mar 2026 20:00:00 +0100

When we use the search function of Chroma, we can ask for cats and find documents related to felines. While this is great to get all cat related content, it may match on too many documents. This "fuzzy" search is a feature made possible by the embedding of our search term and how vectors relate to each other. But that also means we cannot simply get a stricter mode if we need one.

Chroma offers us an addition to the query method that allows us to filter based on the metadata of a document. That way we can combine the "fuzzy" vector search with a strict search based on metadata. Let us see how we can use it with our data.