Skip to content

AI

  • in AI
  • 7 min read

#338: Multi-Agents in LangGraph

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.

  • in AI
  • 3 min read

#336: Build a MCP Server With FastMCP

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.

  • in AI
  • 6 min read

#335: Handle the Raspberry-Test in LangGraph

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.

  • in AI
  • 5 min read

#334: Create Subgraphs in LangGraph

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.

  • in AI
  • 3 min read

#332: Long-Term Memory in LangGraph

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.

  • in AI
  • 6 min read

#330: Selective Approval With LangGraph

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.