🔵 What is a graph

A graph is a data structure — an organized way to store information — and it consists of just two things. The first is the at the. A node is a thing: a person, a step in your process, a ticket, a document, an AI agent. If you can point to something and say “this here,” it can be a node.

What to look at: four nodes and zero lines. Notice that nothing here tells you anything interesting — it's just a bunch of stuff. A graph only starts to matter when you connect things. That's what we do in the next topic.

The second (and final) piece is the edge — in English edge, written as e in algorithms. An edge is the relationship between two nodes. If the node is a noun, the edge is a verb: “depends on,” “becomes,” “knows,” “delivers the result to.”

What to look at: compare it with the previous diagram — they’re the same four nodes. The only thing that changed was the three labeled lines. And that alone lets you answer questions the list couldn’t: “who produced this document?”, “what does the agent depend on to work?”.

An edge can work in both directions or just one. When it has an arrow, the graph is directed (directed): it went from A to B and doesn’t return along that edge. Friendship is undirected (if I’m your friend, you’re mine). But “the researcher hands it off to the writer” is directed — the reverse doesn’t make sense.

Weight (edge weight, sometimes written as ew) and is a number attached to the edge. Minutes, dollars, tokens, probability, confidence. It’s the ingredient that turns a nice-looking diagram into a structure you can calculate: which path is faster, cheaper, more reliable.

The cheapest example to understand is your morning. You asleep are one node. You awake are another. Two minutes pass between waking up and getting out of bed—that 2 is the weight. Five from getting up to brushing your teeth. Three from brushing your teeth to coffee in the cup. A weighted graph already answers “how long does it take to get from bed to coffee?”—and lets you compare alternative paths.

What to look at: the little numbers above the arrows. Add them up along a path and you get the cost of that path. The dashed cyan line is a shortcut: skips two nodes and costs 4 instead of 10. Finding this kind of shortcut is literally what shortest-path algorithms do—and what you’ll want from your agent graph when the weight is “cost in tokens.”

Cycle is a path that starts at a node and returns to it. When a directed graph no has no cycles, it gets a name you'll hear a lot: DAG, by Directed Acyclic Graph — directed acyclic graph. It has been the standard workflow format for decades (every data pipeline, every build, and every CI system is a DAG).

What to look at: both sides are graphs. The only difference is the bottom line on the right, which closes the loop. That line has two effects: (1) the graph can now repeat work — which is exactly what you want from an agent — and (2) it loses the guarantee that it will finish. That’s why every cycle needs a stopping condition.

Lists, trees, and graphs are the same family with different rules for how many connections each node can have. List: each item points to the next, forming a queue. Tree: each node has exactly one “parent,” nothing loops back. Graph: Anything can connect to anything. Lists and trees are special cases of graphs.

// 1) O grafo: lista de adjacencia + pesos (minutos)
const grafo = {
  "dormindo": { "acordar": 0 },
  "acordar":  { "levantar": 2, "cafe": 4 },   // 'cafe' e o atalho
  "levantar": { "dentes": 5 },
  "dentes":   { "cafe": 3 },
  "cafe":     {}
};

// 2) Todos os caminhos de um no ate outro, com custo
function caminhos(g, de, ate, visitados = [], custo = 0) {
  if (de === ate) return [{ rota: [...visitados, de], custo }];
  if (visitados.includes(de)) return [];          // corta ciclo
  return Object.entries(g[de] || {}).flatMap(([viz, peso]) =>
    caminhos(g, viz, ate, [...visitados, de], custo + peso)
  );
}

const r = caminhos(grafo, "dormindo", "cafe");
r.sort((a, b) => a.custo - b.custo);
r.forEach(c => console.log(c.custo + " min:", c.rota.join(" → ")));