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

If you map out every person on Earth as a node and every acquaintance as an edge, you've essentially built an unweighted, undirected graph. In this setup, "unweighted" means we don't care if you're best friends or just met once—a connection is a connection. "Undirected" just means if I know you, you know me. When you're trying to figure out the minimum number of introductions needed to reach a celebrity like Pedro Pascal, you're really just solving for the shortest path between node A and node B.

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.