diff --git a/lib/dependency_graph.py b/lib/dependency_graph.py
new file mode 100644
index 0000000..72e3f48
--- /dev/null
+++ b/lib/dependency_graph.py
@@ -0,0 +1,333 @@
+# Copyright 2021 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""DependencyGraph class.
+
+At time of writing, the DependencyGraph is only used by the depgraph lib to
+produce graphs from portage, but this class is decoupled from that file to
+allow it to be used elsewhere. For example, the package index file in binhosts
+contain enough information to generate a graph, and does not require portage
+imports to parse.
+"""
+
+import collections
+import enum
+import sys
+from typing import Iterable, Iterator, List, Set, Union
+
+from chromite.lib import cros_build_lib
+from chromite.lib import cros_logging as logging
+from chromite.lib.parser import package_info
+
+assert sys.version_info >= (3, 6), 'This module requires Python 3.6+'
+
+
+class Error(Exception):
+  """Base module error."""
+
+
+class NodeCollisionError(Error):
+  """Found multiple nodes representing the same package."""
+
+
+class SysrootValueError(Error, ValueError):
+  """Sysroot argument value not valid."""
+
+
+class PackageNode:
+  """A package vertex in the depgraph.
+
+  Attributes:
+    pkg_info: The package the node represents.
+    root: The root where the package is to be installed.
+    _deps: The set of packages this package depends on.
+    _rev_deps: The set of packages that depend on this package.
+  """
+  pkg_info: package_info.PackageInfo
+  root: str
+
+  def __init__(self, pkg_info: package_info.PackageInfo, root: str):
+    self.pkg_info = pkg_info
+    self.root = root
+    self._deps = set()
+    self._rev_deps = set()
+
+  def __eq__(self, other: Union['PackageNode', package_info.PackageInfo]):
+    if isinstance(other, PackageNode):
+      return (self.pkg_info == other.pkg_info and
+              self.root == other.root and
+              self._deps == set(other.dependencies) and
+              self._rev_deps == set(other.reverse_dependencies))
+    elif isinstance(other, package_info.PackageInfo):
+      return self.pkg_info == other
+    else:
+      return False
+
+  def __hash__(self):
+    return hash((self.name, self.root))
+
+  def __str__(self):
+    return f'PackageNode<{self.pkg_info} in {self.root}>'
+
+  def __repr__(self):
+    # Build truncated strings for deps and rdeps.
+    truncated_len = 3
+    deplen = min(len(self._deps), truncated_len)
+    deps = ', '.join(str(p) for p in list(self._deps)[:deplen])
+    if len(self._deps) > deplen:
+      deps += ', ...'
+    rdeplen = min(len(self._rev_deps), truncated_len)
+    rdeps = ', '.join(str(p) for p in list(self._rev_deps)[:rdeplen])
+    if len(self._rev_deps) > rdeplen:
+      rdeps += ', ...'
+    return (f'PackageNode<pkg_info: "{self.pkg_info}", root: "{self.root}", '
+            f'deps: "{deps}", reverse deps: "{rdeps}">')
+
+  @property
+  def dependencies(self) -> Iterable['PackageNode']:
+    """Get the packages this one depends on."""
+    yield from self._deps
+
+  @property
+  def reverse_dependencies(self) -> Iterable['PackageNode']:
+    """Get the packages that depend on this one."""
+    yield from self._rev_deps
+
+  @property
+  def atom(self):
+    """Get the package atom ("category/package")."""
+    return self.pkg_info.atom
+
+  @property
+  def name(self):
+    """Get the node name, a unique identifier for the package itself."""
+    return self.pkg_info.cpvr
+
+  def add_dependency(self, dependency: 'PackageNode'):
+    """Add a package as a dependency of this node.
+
+    Also registers this package as a reverse dependency of the other.
+    """
+    self._deps.add(dependency)
+    dependency.add_reverse_dependency(self)
+
+  def add_reverse_dependency(self, dependency: 'PackageNode'):
+    """Add a reverse dependency.
+
+    This method is not generally meant to be used directly. Use add_dependency
+    to build out a DependencyGraph.
+    """
+    self._rev_deps.add(dependency)
+
+
+@enum.unique
+class RootType(enum.Enum):
+  """Root type enum for DependencyGraph."""
+  SYSROOT = enum.auto()
+  SDK = enum.auto()
+  ALL = enum.auto()
+
+
+class DependencyGraph:
+  """Dependency graph data structure.
+
+  Data structure to enable more easily querying and traversing the depgraphs.
+  Querying the depgraph currently supports the full CPVR package spec, and
+  package atoms. The behavior of other package specs (e.g. CPV) is undefined.
+  """
+
+  def __init__(self, nodes: Iterable[PackageNode],
+               sysroot: Union[str, 'sysroot_lib.Sysroot'],
+               root_packages: List[Union[str, package_info.PackageInfo]]):
+    """DependencyGraph init.
+
+    The |nodes| are expected to already have their dependencies added.
+
+    Args:
+      nodes: The PackageNodes for the depgraph.
+      sysroot: The sysroot the dependency graph was built from.
+      root_packages: The packages emerged to create this depgraph.
+    """
+    ### Add all of the nodes to our internal structure.
+    # The pkg/atom_dict are nested dictionaries. The first key is the package
+    # CPF (category/package-version-revision). The next key is the package's
+    # target root. This allows identifying packages that are installed to both
+    # the sysroot and the SDK.
+    self._pkg_dict = collections.defaultdict(dict)
+    # The atom_list is a dictionary containing the list of packages that map
+    # to a specific atom. Many packages will have a single entry, but the list
+    # may contain multiple when a package is installed to both the sysroot
+    # and the SDK root, and/or could contain multiple versions of a package.
+    self._atom_list = collections.defaultdict(list)
+    self._roots = set()
+    self._len = 0
+
+    for node in nodes:
+      self._add_node(node)
+
+    ### Verify found roots and store roots information.
+    # Each entry should be installed to either the SDK (BDEPEND) or to
+    # the sysroot (DEPEND/RDEPEND). Zero roots is possible only when the
+    # depgraph is empty.
+    assert 0 <= len(self._roots) <= 2, 'Unexpected roots: {self._roots}'
+
+    # Figure out which roots we have roots, and that they're the ones we expect.
+    given_sysroot = getattr(sysroot, 'path', sysroot)
+    sdk_root = cros_build_lib.GetSysroot()
+    is_sdk_graph = given_sysroot == sdk_root
+    # Store the SDK (bdeps) root when present and it's not the SDK's depgraph.
+    self.sdk_root = (
+        sdk_root if sdk_root in self._roots and not is_sdk_graph else None)
+    self.sysroot_path = given_sysroot if given_sysroot in self._roots else None
+
+    if not self.sysroot_path:
+      # Given sysroot could not be confirmed. It could mean we were given a bad
+      # value, or just that nothing needed to be installed to the sysroot.
+
+      # found_sysroot should always be either empty, or a set with exactly one
+      # element in it.
+      found_sysroot = self._roots - {self.sdk_root}
+      if found_sysroot:
+        raise SysrootValueError(
+            f'Found sysroot {found_sysroot} does not match given sysroot '
+            f'({given_sysroot}).')
+      else:
+        # Since it's valid no packages could be installed to it, just notify
+        # the user.
+        logging.info('Given %s but depgraph did not contain any packages '
+                     'installed to it.', given_sysroot)
+
+    ### Save the references to the root package nodes.
+    # This must be done after the root information processing for the root
+    # filtering functionality in _get_nodes().
+    self._root_package_nodes = []
+    for pkg in [package_info.parse(p) for p in root_packages]:
+      self._root_package_nodes.extend(self.get_nodes(pkg, RootType.SYSROOT))
+
+  def __contains__(
+      self, item: Union[str, package_info.PackageInfo, PackageNode]) -> bool:
+    """Check if the given package is in the depgraph."""
+    if isinstance(item, PackageNode):
+      return item.atom in self._atom_list and item in self._atom_list[item.atom]
+    elif isinstance(item, package_info.PackageInfo):
+      return item.cpvr in self._pkg_dict or item.atom in self._atom_list
+    else:
+      return item in self._pkg_dict or item in self._atom_list
+
+  def __iter__(self):
+    """BFS traversal of the depgraph."""
+    pkgs = collections.deque(self._root_package_nodes)
+    seen = set()
+    while pkgs:
+      pkg = pkgs.popleft()
+      if pkg in seen:
+        continue
+      seen.add(pkg)
+      pkgs.extend(pkg.dependencies)
+
+      yield pkg
+
+  def __len__(self):
+    """Size of the depgraph."""
+    return self._len
+
+  def _add_node(self, node: PackageNode):
+    """Add a package and its dependencies to the graph."""
+    if node.root in self._pkg_dict[node.name]:
+      if self._pkg_dict[node.name][node.root] == node:
+        # Ignore if re-adding.
+        return
+      else:
+        raise NodeCollisionError(f'Different node already exists for {node}.')
+
+    # Add node.
+    self._pkg_dict[node.name][node.root] = node
+    self._atom_list[node.atom].append(node)
+    self._roots.add(node.root)
+    self._len += 1
+    for dep in node.dependencies:
+      self._add_node(dep)
+
+  def _get_roots(self, root: RootType = RootType.ALL) -> Set[str]:
+    """Helper to translate RootType value to a set of roots."""
+    if root is RootType.SDK:
+      return self._roots & {self.sdk_root}
+    elif root is RootType.SYSROOT:
+      return self._roots & {self.sysroot_path}
+    else:
+      return self._roots
+
+  def get_nodes(self, pkg: Union[package_info.PackageInfo, str],
+                root_type: RootType = RootType.ALL) -> List[PackageNode]:
+    """Get all nodes matching the given package and root type."""
+    pkg_info = package_info.parse(pkg)
+    roots = self._get_roots(root_type)
+    if pkg_info.cpvr in self._pkg_dict:
+      # Have exact match.
+      nodes = []
+      for root in roots:
+        if root in self._pkg_dict[pkg_info.cpvr]:
+          nodes.append(self._pkg_dict[pkg_info.cpvr][root])
+      return nodes
+    elif pkg_info.atom in self._atom_list:
+      # Given an atom string.
+      return [x for x in self._atom_list[pkg_info.atom] if x.root in roots]
+    else:
+      return []
+
+  def is_dependency(self, dep_pkg: Union[package_info.PackageInfo, str],
+                    src_pkg: Union[package_info.PackageInfo, str],
+                    dep_root_type: RootType = RootType.ALL,
+                    src_root_type: RootType = RootType.ALL,
+                    direct: bool = False) -> bool:
+    """Check if |dep_pkg| is in the dependency graph of |src_pkg|.
+
+    Args:
+      dep_pkg: The potential dependency package.
+      src_pkg: The root of the subgraph to search for |dep_pkg|.
+      dep_root_type: Filters the root when finding |dep_pkg|.
+      src_root_type: Filters the root when finding |src_pkg|.
+      direct: Only search direct dependencies when set to True.
+    """
+    dep_pkg_nodes = self.get_nodes(dep_pkg, dep_root_type)
+    src_pkg_nodes = self.get_nodes(src_pkg, src_root_type)
+
+    if not dep_pkg_nodes or not src_pkg_nodes:
+      # One or both not in the graph at all.
+      return False
+    elif direct:
+      # Only check the direct dependencies.
+      return any(d in s.dependencies
+                 for d in dep_pkg_nodes
+                 for s in src_pkg_nodes)
+    else:
+      # Check if it's in the subgraph(s) rooted at src_pkg.
+      subgraph = DependencyGraph(src_pkg_nodes, self.sysroot_path, [src_pkg])
+      return any(x in subgraph for x in dep_pkg_nodes)
+
+  def get_dependencies(
+      self,
+      pkg: Union[package_info.PackageInfo, str],
+      root_type: RootType = RootType.ALL) -> Iterator[PackageNode]:
+    """Get the dependencies for a package.
+
+    Use |root_type| to differentiate between the instances installed to the SDK
+    and sysroot. Generates an empty list for packages not in the graph (or when
+    filtered to a root the package isn't installed to). Does not ensure a
+    unique list when multiple nodes are found.
+    """
+    for node in self.get_nodes(pkg, root_type):
+      yield from node.dependencies
+
+  def get_reverse_dependencies(
+      self,
+      pkg: Union[package_info.PackageInfo, str],
+      root_type: RootType = RootType.ALL) -> Iterator[PackageNode]:
+    """Get the reverse dependencies for a package.
+
+    Like get_dependencies(), but get the reverse dependencies for the package.
+    See get_dependencies() for more information.
+    """
+    for node in self.get_nodes(pkg, root_type):
+      yield from node.reverse_dependencies
diff --git a/lib/dependency_graph_unittest.py b/lib/dependency_graph_unittest.py
new file mode 100644
index 0000000..5230a80
--- /dev/null
+++ b/lib/dependency_graph_unittest.py
@@ -0,0 +1,306 @@
+# Copyright 2021 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Unit tests for dependency_graph.py."""
+
+import pytest
+
+from chromite.lib import dependency_graph
+from chromite.lib.parser import package_info
+
+
+def _build_depgraph():
+  """Build a DependencyGraph to test against."""
+  sysroot = '/build/target'
+  sdk_root = '/'
+
+  virtual = package_info.parse('virtual/target-foo-1.2.3')
+  dep = package_info.parse('cat/dep-1.0.0-r1')
+  depdep = package_info.parse('cat/depdep-2.0.1-r5')
+  bdep = package_info.parse('cat/bdep-3.4')
+
+  virtual_node = dependency_graph.PackageNode(virtual, sysroot)
+  dep_node = dependency_graph.PackageNode(dep, sysroot)
+  depdep_node = dependency_graph.PackageNode(depdep, sysroot)
+  bdep_node = dependency_graph.PackageNode(bdep, sdk_root)
+  depbdep_node = dependency_graph.PackageNode(dep, sdk_root)
+
+  virtual_node.add_dependency(dep_node)
+  virtual_node.add_dependency(bdep_node)
+  virtual_node.add_dependency(depbdep_node)
+  dep_node.add_dependency(depdep_node)
+  depbdep_node.add_dependency(depdep_node)
+
+  nodes = (virtual_node, dep_node, depdep_node, bdep_node, depbdep_node)
+
+  return dependency_graph.DependencyGraph(nodes, sysroot, [virtual])
+
+
+def test_dependency_graph_incorrect_sysroot():
+  """Test building a graph with the wrong sysroot fails."""
+  pkg = package_info.parse('foo/bar-1.0-r2')
+  sdk_root = '/'
+  sysroot = '/build/target'
+  n1 = dependency_graph.PackageNode(pkg, sdk_root)
+  n2 = dependency_graph.PackageNode(pkg, sysroot)
+
+  with pytest.raises(dependency_graph.SysrootValueError):
+    dependency_graph.DependencyGraph([n1, n2],
+                                     sysroot='/wrong/sysroot',
+                                     root_packages=[pkg])
+
+
+def test_create_invalid_depgraph_too_many_roots():
+  """Test building a graph with too many roots fails."""
+  pkg = package_info.parse('foo/bar-1.0-r2')
+  n1 = dependency_graph.PackageNode(pkg, '/')
+  n2 = dependency_graph.PackageNode(pkg, '/build/target')
+  n3 = dependency_graph.PackageNode(pkg, '/build/other')
+
+  with pytest.raises(AssertionError):
+    dependency_graph.DependencyGraph([n1, n2, n3],
+                                     sysroot='/build/target',
+                                     root_packages=[pkg])
+
+
+def test_create_invalid_depgraph_node_conflict():
+  """Test building a graph with non-equivalent nodes for one package fails."""
+  pkg = package_info.parse('foo/bar-1.0-r2')
+  dep = package_info.parse('foo/baz-2.0')
+  sysroot = '/build/target'
+  pkg_node = dependency_graph.PackageNode(pkg, sysroot)
+  pkg_node2 = dependency_graph.PackageNode(pkg, sysroot)
+  dep_node = dependency_graph.PackageNode(dep, sysroot)
+  pkg_node.add_dependency(dep_node)
+
+  with pytest.raises(dependency_graph.NodeCollisionError):
+    dependency_graph.DependencyGraph([pkg_node, dep_node, pkg_node2],
+                                     sysroot=sysroot,
+                                     root_packages=[pkg])
+
+
+def test_create_valid_depgraph_duplicate_nodes():
+  """Test deduplication of nodes in depgraph creation."""
+  pkg = package_info.parse('foo/bar-1.0-r2')
+  dep = package_info.parse('foo/baz-2.0')
+  sysroot = '/build/target'
+
+  pkg_node = dependency_graph.PackageNode(pkg, sysroot)
+  pkg_node2 = dependency_graph.PackageNode(pkg, sysroot)
+  pkg_node3 = dependency_graph.PackageNode(pkg, sysroot)
+  dep_node = dependency_graph.PackageNode(dep, sysroot)
+
+  pkg_node.add_dependency(dep_node)
+  pkg_node2.add_dependency(dep_node)
+  pkg_node3.add_dependency(dep_node)
+
+  assert pkg_node == pkg_node2 == pkg_node3
+  assert len(list(dep_node.reverse_dependencies)) == 1
+
+  # Add multiple instances of the same node instance, plus multiple equal nodes.
+  packages = (pkg_node, pkg_node, pkg_node2, pkg_node3, dep_node)
+  graph = dependency_graph.DependencyGraph(
+      packages, sysroot=sysroot, root_packages=[pkg])
+  # Should only have the nodes for the two packages at the end.
+  assert len(graph) == 2
+
+
+def test_dependency_graph_roots():
+  """Test the roots get parsed correctly."""
+  graph = _build_depgraph()
+
+  assert graph.sdk_root == '/'
+  assert graph.sysroot_path == '/build/target'
+
+
+def test_dependency_graph_len():
+  """Test the graph size."""
+  graph = _build_depgraph()
+  assert len(graph) == 5
+
+
+def test_dependency_graph_in():
+  """Test __contains__."""
+  graph = _build_depgraph()
+
+  virtual = package_info.parse('virtual/target-foo-1.2.3')
+
+  # Full package info instance should be found (via cpvr).
+  assert virtual in graph
+  # CPVR string should be found.
+  assert virtual.cpvr in graph
+  # Atom string should be found.
+  assert virtual.atom in graph
+  # Package not in graph should not be found.
+  assert 'not/in-1.0' not in graph
+
+
+def test_dependency_graph_iter():
+  """Test __iter__ BFS traversal."""
+  graph = _build_depgraph()
+
+  virtual = package_info.parse('virtual/target-foo-1.2.3')
+  dep = package_info.parse('cat/dep-1.0.0-r1')
+  depdep = package_info.parse('cat/depdep-2.0.1-r5')
+  bdep = package_info.parse('cat/bdep-3.4')
+
+  # Expected Order:
+  # 1. the root package (virtual/target-foo).
+  # 2-4. cat/dep (sysroot), cat/dep (sdk), cat/bdep in any order.
+  # 5. depdep.
+  expected_order = [[virtual], [dep, bdep], [dep, bdep], [dep, bdep], [depdep]]
+  for i, node in enumerate(graph):
+    assert node.pkg_info in expected_order[i]
+
+
+def test_dependency_graph_get_nodes():
+  """Test get_nodes retrieves the expected results."""
+  graph = _build_depgraph()
+
+  virtual = package_info.parse('virtual/target-foo-1.2.3')
+  virtual_atom = package_info.parse('virtual/target-foo')
+
+  # Test fetching by different values.
+  pi_nodes = graph.get_nodes(virtual)
+  cpvr_nodes = graph.get_nodes(virtual.cpvr)
+  atom_nodes = graph.get_nodes(virtual.atom)
+  pi_atom_nodes = graph.get_nodes(virtual_atom)
+  assert pi_nodes == cpvr_nodes == atom_nodes == pi_atom_nodes
+
+
+def test_dependency_graph_get_nodes_by_roots():
+  """Test get_nodes correctly filters by the root types."""
+  graph = _build_depgraph()
+
+  dep = package_info.parse('cat/dep-1.0.0-r1')
+
+  # Verify the correct counts.
+  dep_all = graph.get_nodes(dep)
+  dep_sysroot = graph.get_nodes(dep, dependency_graph.RootType.SYSROOT)
+  dep_sdk = graph.get_nodes(dep, dependency_graph.RootType.SDK)
+  assert len(dep_all) == 2
+  assert len(dep_sysroot) == 1
+  assert len(dep_sdk) == 1
+
+  # Verify we got the correct nodes.
+  dep_sysroot_node = dep_sysroot.pop()
+  dep_sdk_node = dep_sdk.pop()
+  assert dep_sysroot_node in dep_all
+  assert dep_sdk_node in dep_all
+  assert dep_sysroot_node.root == '/build/target'
+  assert dep_sdk_node.root == '/'
+
+
+def test_dependency_graph_get_nodes_multi_version_package():
+  """Test handling of multiple packages with different versions."""
+  virtual = package_info.parse('virtual/foo-1.0')
+  pkg1 = package_info.parse('cat/pkg-1.0')
+  pkg2 = package_info.parse('cat/pkg-2.0')
+
+  sysroot = '/build/target'
+  sdk = '/'
+
+  virtual_pn = dependency_graph.PackageNode(virtual, sysroot)
+  pkg1_pn = dependency_graph.PackageNode(pkg1, sysroot)
+  pkg1_pn_sdk = dependency_graph.PackageNode(pkg1, sdk)
+  pkg2_pn = dependency_graph.PackageNode(pkg2, sysroot)
+  pkg2_pn_sdk = dependency_graph.PackageNode(pkg2, sdk)
+
+  virtual_pn.add_dependency(pkg1_pn)
+  virtual_pn.add_dependency(pkg1_pn_sdk)
+  virtual_pn.add_dependency(pkg2_pn)
+  virtual_pn.add_dependency(pkg2_pn_sdk)
+
+  graph = dependency_graph.DependencyGraph((virtual_pn,),
+                                           sysroot, root_packages=[virtual])
+
+  # Should get both instances of cat/pkg-1.0.
+  assert len(graph.get_nodes(pkg1)) == 2
+  assert len(graph.get_nodes(pkg1.cpvr)) == 2
+  assert all(p.pkg_info.cpvr == pkg1.cpvr for p in graph.get_nodes(pkg1))
+
+  # Should get both instances of cat/pkg-2.0.
+  assert len(graph.get_nodes(pkg2)) == 2
+  assert len(graph.get_nodes(pkg2.cpvr)) == 2
+  assert all(p.pkg_info.cpvr == pkg2.cpvr for p in graph.get_nodes(pkg2))
+
+  atom = package_info.parse(pkg1.atom)
+  # Should get both instances of cat/pkg-1.0 and both instances of cat/pkg-2.0.
+  assert len(graph.get_nodes(atom)) == 4
+  assert len(graph.get_nodes(atom.atom)) == 4
+  assert all(p.pkg_info.atom == atom.atom for p in graph.get_nodes(atom))
+
+
+def test_dependency_graph_dependencies():
+  """Tests for get_dependencies and get_reverse_dependencies."""
+  graph = _build_depgraph()
+
+  virtual = package_info.parse('virtual/target-foo-1.2.3')
+  dep = package_info.parse('cat/dep-1.0.0-r1')
+  depdep = package_info.parse('cat/depdep-2.0.1-r5')
+  bdep = package_info.parse('cat/bdep-3.4')
+
+  dep_nodes = graph.get_nodes(dep)
+  bdep_node = graph.get_nodes(
+      bdep, root_type=dependency_graph.RootType.SDK).pop()
+  # The virtual has three dependencies; dep x2(sdk + sysroot), and bdep.
+  assert set(graph.get_dependencies(virtual)) == {*dep_nodes, bdep_node}
+  # Virtual has no revdeps.
+  assert not list(graph.get_reverse_dependencies(virtual))
+
+  # Leaf node has no dependencies.
+  assert not list(graph.get_dependencies(depdep))
+  # Leaf node has two revdeps.
+  assert set(graph.get_reverse_dependencies(depdep)) == set(dep_nodes)
+
+
+def test_dependency_graph_is_dependency():
+  """Test is_dependency method."""
+  graph = _build_depgraph()
+
+  virtual = package_info.parse('virtual/target-foo-1.2.3')
+  dep = package_info.parse('cat/dep-1.0.0-r1')
+  depdep = package_info.parse('cat/depdep-2.0.1-r5')
+  bdep = package_info.parse('cat/bdep-3.4')
+
+  # Direct dependency.
+  assert graph.is_dependency(dep, virtual)
+  # Specifying direct=True should make no difference.
+  assert graph.is_dependency(dep, virtual, direct=True)
+  # Indirect dependency.
+  assert graph.is_dependency(depdep, virtual)
+  # Indirect dependency checking direct only.
+  assert not graph.is_dependency(depdep, virtual, direct=True)
+  # Not a dependency.
+  assert not graph.is_dependency(depdep, bdep)
+
+
+def test_dependency_graph_is_dependency_root_types():
+  """Test is_dependency method when using the root type filters."""
+  graph = _build_depgraph()
+
+  virtual = package_info.parse('virtual/target-foo-1.2.3')
+  bdep = package_info.parse('cat/bdep-3.4')
+
+  # Valid dependency when filtering roots.
+  # bdep is in the SDK.
+  assert graph.is_dependency(
+      bdep, virtual, dep_root_type=dependency_graph.RootType.SDK)
+  # bdep is also direct dependency.
+  assert graph.is_dependency(
+      bdep, virtual, dep_root_type=dependency_graph.RootType.SDK, direct=True)
+  # virtual is in the sysroot.
+  assert graph.is_dependency(
+      bdep,
+      virtual,
+      dep_root_type=dependency_graph.RootType.SDK,
+      src_root_type=dependency_graph.RootType.SYSROOT)
+
+  # Invalid dependency when filtering roots.
+  # bdep is not in the sysroot.
+  assert not graph.is_dependency(
+      bdep, virtual, dep_root_type=dependency_graph.RootType.SYSROOT)
+  # virtual is not in the SDK.
+  assert not graph.is_dependency(
+      bdep, virtual, src_root_type=dependency_graph.RootType.SDK)
diff --git a/lib/depgraph.py b/lib/depgraph.py
index f5b16d4..ec538e5 100644
--- a/lib/depgraph.py
+++ b/lib/depgraph.py
@@ -17,6 +17,7 @@
 from chromite.lib import constants
 from chromite.lib import cros_logging as logging
 from chromite.lib import cros_test_lib
+from chromite.lib import dependency_graph
 from chromite.lib.parser import package_info
 
 assert sys.version_info >= (3, 6), 'This module requires Python 3.6+'
@@ -862,8 +863,9 @@
 
 
 # Depgraph results data container used by the raw depgraph functions. The
-# deps attribute has the main depgraph info, while the bdeps attribute
-# contains just the bdepends depgraph, i.e. the depgraph installed to the SDK.
+# deps attribute has the main depgraph info (DEPEND, RDEPEND, and optionally
+# BDEPEND), while the bdeps attribute contains just the bdepends depgraph,
+# i.e. the depgraph installed to the SDK.
 DepgraphResult = collections.namedtuple('DepgraphResult',
                                         ('deps', 'bdeps', 'packages'))
 
@@ -981,3 +983,60 @@
   deps_tree, _deps_info, bdeps_tree = deps.GenDependencyTree()
   return DepgraphResult(deps=deps_tree, bdeps=bdeps_tree, packages=packages)
 
+
+def get_sdk_dependency_graph(
+    pkgs: Optional[Union[List[str], List[package_info.PackageInfo]]] = None
+) -> dependency_graph.DependencyGraph:
+  """Get the DependencyGraph for the SDK itself."""
+  result = _get_raw_sdk_depgraph(packages=pkgs)
+  return _create_graph_from_deps(result.deps,
+                                 sysroot=cros_build_lib.GetSysroot(board=None),
+                                 packages=result.packages)
+
+
+def get_sysroot_dependency_graph(
+    sysroot: Union[str, 'sysroot_lib.Sysroot'],
+    packages: Optional[Union[List[str], List[package_info.PackageInfo]]] = None
+) -> dependency_graph.DependencyGraph:
+  """Get the DependencyGraph for the sysroot only."""
+  result = _get_raw_sysroot_depgraph(sysroot, packages=packages)
+  return _create_graph_from_deps(result.deps, sysroot, result.packages)
+
+
+def get_build_target_dependency_graph(
+    sysroot: Union[str, 'sysroot_lib.Sysroot'],
+    packages: Optional[Union[List[str], List[package_info.PackageInfo]]] = None
+) -> dependency_graph.DependencyGraph:
+  """Get the DependencyGraph for the sysroot and its bdeps."""
+  result = _get_raw_build_target_depgraph(sysroot, packages=packages)
+  return _create_graph_from_deps(result.deps, sysroot, result.packages)
+
+
+def _create_graph_from_deps(
+    deps: dict, sysroot: Union[str, 'sysroot_lib.Sysroot'],
+    packages: Union[List[str], List[package_info.PackageInfo]]
+) -> dependency_graph.DependencyGraph:
+  """Create DependencyGraph from the raw DepGraphGenerator deps.
+
+  Translate the raw DepGraphGenerator deps into PackageNodes for a
+  DependencyGraph. This is extracted from the DependencyGraph class to make
+  testing the DependencyGraph class itself much easier.
+  """
+  node_dict = collections.defaultdict(dict)
+  nodes = []
+  for pkg_cpv, pkg_data in deps.items():
+    pkg_info = package_info.parse(pkg_cpv)
+    node = dependency_graph.PackageNode(pkg_info, pkg_data['root'])
+    node_dict[pkg_info][pkg_data['root']] = node
+    nodes.append(node)
+
+  for pkg_cpv, pkg_data in deps.items():
+    pkg_info = package_info.parse(pkg_cpv)
+    pkg_node = node_dict[pkg_info][pkg_data['root']]
+    for dep_cpv, dep_data in pkg_data['deps'].items():
+      dep_info = package_info.parse(dep_cpv)
+      dep_node = node_dict[dep_info][dep_data['root']]
+      pkg_node.add_dependency(dep_node)
+
+  return dependency_graph.DependencyGraph(
+      nodes, sysroot=sysroot, root_packages=packages)