Graphs processing in Scala
One of the important traits of Scala is that it very well supports the functional programming, and of the advantages of functional programming is that is makes the reasoning of the functions easier. This is easier if the functions do not have side effects and if the used data structures are immutable. 

Immutable data structures and pure functions are not always the best option, but in a graph library I thing they might be suitable. 

So in your code I'd change the Graph to be an immutable class (see sample below).

Another problem with your code you have notices yourself. It is the strange coupling of the graph and the node classes. A graph is a structure that contains the nodes and the edges. In your code however the graph does not have any information about the edges itself, the nodes are responsible for holding the information about the edges. This could become problematic if you add only the node a to the graph and the node a has edges to other nodes, not known to the graph. Also, with the current design, you cannot reuse the same node object in multiple graphs. Also in your code there is no guarantee that when the node a has an outgoing edge to b that there is a corresponding edge on b incoming from a.

Here a sample of immutable classes for the Node and the Graph. Note that this structure is not optimal at all, as the information about the incoming and outgoing edges is not stored efficiently, but this can be done easily with some maps, depending on the algorithms you want to develop. Another note: The graph in my sample stores the nodes and the edges a bit redundantly. It would be enough to store just the edges, if isolated nodes are not needed.

case class Node[+T](i: T)

class Graph[N &lt;: Node[T], +T](someNodes:Set[N], val edges:Set[(N,N)]) {

  // someNodes does not necessarily contains all nodes from the edges, nodes does
  val nodes: Set[N] = someNodes ++ edges.map(_._1) ++ edges.map(_._2)

  def addVortex(node:N) = new Graph(nodes + node, edges)

  def addEdge(edge: (N, N)) = new Graph(nodes + edge._1 + edge._2, edges + edge)

  // Redundant, but more efficient data structure for the outgoing edges
  lazy val outgoingEdges: Map[N, Set[N]] = edges.groupBy(_._1).mapValues(s =&gt; s.map(_._2))

  // Here come your algorithms
}