BFS is the absolute best way to find the shortest path between

For anyone building an AI workflow or a custom LLM agent that needs to traverse relational data, understanding the adjacency list is the first step. It's the most efficient way to represent this in code:

const graph = {
 Alexandra: ["Maria", "John"],
 Maria: ["Alexandra", "Sofia"],
 Sofia: ["Maria", "Pedro"],
 Pedro: ["Sofia"],
 John: ["Alexandra", "Elena"],
 Elena: ["John", "Carlos"],
 Carlos: ["Elena"],
};

The danger in graph traversal is the infinite loop. If you just wander randomly, you'll end up bouncing between two people forever (Alexandra → Maria → Sofia → Maria...). To fix this, you need a strict exploration order and a way to track where you've already been.

This is where Breadth-First Search (BFS) shines. Instead of diving deep into one friendship chain, BFS explores in "levels." It checks everyone one connection away, then everyone two connections away, and so on. The second you hit your target, you've guaranteed the shortest possible path because every shorter route has already been exhausted.

Here is a practical tutorial on how to implement this search logic from scratch. I've used a queue to manage the exploration and a Set

to keep track of visited nodes so we don't loop.

function introductionsAway(graph, start, target) {
 if (start === target) return { degrees: 0, path: [start] };

 const visited = new Set([start]);
 const queue = [[start, [start]]]; 

 while (queue.length > 0) {
 const [person, path] = queue.shift();

 for (const friend of graph[person] || []) {
 if (visited.has(friend)) continue;
 if (friend === target) {
 return { degrees: path.length, path: [...path, friend] };
 }

 visited.add(friend);
 queue.push([friend, [...path, friend]]);
 }
 }

 return { degrees: -1, path: [] };
}

When you actually run this, the queue

stores not just the current person, but the full path taken to get to them. This allows the function to return the exact chain of introductions. While this assumes all relationships are equal, real-world data is usually "weighted"—meaning some connections are stronger than others. If you start adding weights to your edges, you'll want to move from BFS to something like Dijkstra's algorithm to find the "strongest" path rather than just the shortest.

Next Mistral AI just gave us a way to pin inference to the US or EU →

All Replies （8） #

@ale3oula? 😄

@ZenMasterhaha no, but i've read his papers. his approach to state space search is honestly genius