diff --git a/core/modules/rdf/lib/Drupal/rdf/EventSubscriber/RouteSubscriber.php b/core/modules/rdf/lib/Drupal/rdf/EventSubscriber/RouteSubscriber.php
new file mode 100644
index 0000000..625e1a3
--- /dev/null
+++ b/core/modules/rdf/lib/Drupal/rdf/EventSubscriber/RouteSubscriber.php
@@ -0,0 +1,65 @@
+<?php
+
+/**
+ * Definition of \Drupal\rdf\EventSubscriber\RouteSubscriber.
+ */
+
+namespace Drupal\rdf\EventSubscriber;
+
+use Drupal\Core\Routing\RouteBuildEvent;
+use Drupal\Core\Routing\RoutingEvents;
+use Drupal\rdf\SiteSchema\SiteSchema;
+use Drupal\rdf\SiteSchema\SchemaConstants;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\Routing\Route;
+
+/**
+ * Subscriber for site-generated schema routes.
+ */
+class RouteSubscriber implements EventSubscriberInterface {
+
+  /**
+   * Adds routes for term types in the site-generated schemas.
+   *
+   * @param \Drupal\Core\Routing\RouteBuildEvent $event
+   *   The route building event.
+   */
+  public function routes(RouteBuildEvent $event) {
+
+    $collection = $event->getRouteCollection();
+
+    // The paths of the site-generated schemas.
+    $schemaPaths = array(
+      SchemaConstants::CONTENT_STAGING,
+      SchemaConstants::SYNDICATION,
+    );
+
+    // Add the routes for all of the terms in both schemas.
+    foreach ($schemaPaths as $schemaPath) {
+      $schema = new SiteSchema($schemaPath);
+      $routes = $schema->getRoutes();
+      foreach ($routes as $controller => $pattern) {
+        $route = new Route($pattern, array(
+          '_controller' => 'Drupal\rdf\SiteSchema\SchemaController::' . $controller,
+          'schema_path' => $schemaPath,
+        ), array(
+          '_method' => 'GET',
+        ));
+        // Create the route name to use in the RouteCollection. Remove the
+        // trailing slash and replace characters, so that a path such as
+        // site-schema/syndication/ becomes rdf.site_schema.syndication.
+        $routeName = 'rdf.' . str_replace(array('-','/'), array('_', '.'), substr_replace($schemaPath ,"",-1));
+        $collection->add($routeName, $route);
+      }
+    }
+  }
+
+  /**
+   * Implements EventSubscriberInterface::getSubscribedEvents().
+   */
+  static function getSubscribedEvents() {
+    $events[RoutingEvents::DYNAMIC] = 'routes';
+    return $events;
+  }
+}
+
diff --git a/core/modules/rdf/lib/Drupal/rdf/MapInputTypesEvent.php b/core/modules/rdf/lib/Drupal/rdf/MapInputTypesEvent.php
new file mode 100644
index 0000000..20be166
--- /dev/null
+++ b/core/modules/rdf/lib/Drupal/rdf/MapInputTypesEvent.php
@@ -0,0 +1,90 @@
+<?php
+
+/**
+ * Defines \Drupal\rdf\MapInputTypesEvent.
+ */
+
+namespace Drupal\rdf;
+
+use Symfony\Component\EventDispatcher\Event;
+
+/**
+ * Represents type mapping as event.
+ */
+class MapInputTypesEvent extends Event {
+
+  /**
+   * An array of incoming RDF type URIs.
+   *
+   * @var array
+   */
+  protected $inputUris;
+
+  /**
+   * An array of entity_type/bundles, keyed by site schema type URI
+   *
+   * @var array
+   */
+  protected $siteSchemaTypes;
+
+  /**
+   * The site schema type URI.
+   *
+   * @var string
+   */
+  protected $siteSchemaUri;
+
+  /**
+   * Constructor.
+   *
+   * @param $inputUris
+   *   An array of incoming RDF type URIs.
+   * @param $siteSchemaTypes
+   *   An array of entity_type/bundles, keyed by site schema type URI.
+   */
+  public function __construct($inputUris, $siteSchemaTypes) {
+    $this->inputUris = $inputUris;
+    $this->siteSchemaTypes = $siteSchemaTypes;
+    $this->siteSchemaUri = FALSE;
+  }
+
+  /**
+   * Gets the input URI.
+   *
+   * @return array
+   *   The array of incoming RDF type URIs.
+   */
+  public function getInputUris() {
+    return $this->inputUris;
+  }
+
+  /**
+   * Gets the cache of internal site schema types.
+   *
+   * @return array
+   *   The cached site schema type array.
+   */
+  public function getSiteSchemaTypes() {
+    return $this->siteSchemaTypes;
+  }
+
+  /**
+   * Gets the site schema URI.
+   *
+   * @return string|bool
+   *   The site schema type URI if set, FALSE if otherwise.
+   */
+  public function getSiteSchemaUri() {
+    return $this->siteSchemaUri;
+  }
+
+  /**
+   * Sets the site schema URI.
+   *
+   * @param string $uri
+   *   The site schema type URI.
+   */
+  public function setSiteSchemaUri($uri) {
+    $this->siteSchemaUri = $uri;
+  }
+}
diff --git a/core/modules/rdf/lib/Drupal/rdf/RdfBundle.php b/core/modules/rdf/lib/Drupal/rdf/RdfBundle.php
new file mode 100644
index 0000000..e32fd8d
--- /dev/null
+++ b/core/modules/rdf/lib/Drupal/rdf/RdfBundle.php
@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\rdf\RdfBundle.
+ */
+
+namespace Drupal\rdf;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\HttpKernel\Bundle\Bundle;
+
+/**
+ * RDF dependency injection container.
+ */
+class RdfBundle extends Bundle {
+
+  /**
+   * Overrides Symfony\Component\HttpKernel\Bundle\Bundle::build().
+   */
+  public function build(ContainerBuilder $container) {
+    $container->register('rdf.route_subscriber', 'Drupal\rdf\EventSubscriber\RouteSubscriber')
+      ->addTag('event_subscriber');
+    $container->register('rdf.site_schema.mapping_manager', 'Drupal\rdf\RdfMappingManager')
+      ->addArgument(new Reference('dispatcher'));
+  }
+}
diff --git a/core/modules/rdf/lib/Drupal/rdf/RdfConstants.php b/core/modules/rdf/lib/Drupal/rdf/RdfConstants.php
new file mode 100644
index 0000000..e3bd9ab
--- /dev/null
+++ b/core/modules/rdf/lib/Drupal/rdf/RdfConstants.php
@@ -0,0 +1,25 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\rdf\RdfConstants
+ */
+
+namespace Drupal\rdf;
+
+/**
+ * Defines constants for RDF terms.
+ */
+abstract class RdfConstants {
+  const RDF_TYPE            = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+  // RDF Schema terms.
+  const RDFS_DOMAIN         = 'http://www.w3.org/2000/01/rdf-schema#domain';
+  const RDFS_IS_DEFINED_BY  = 'http://www.w3.org/2000/01/rdf-schema#isDefinedBy';
+  const RDFS_RANGE          = 'http://www.w3.org/2000/01/rdf-schema#range';
+  const RDFS_SUB_CLASS_OF   = 'http://www.w3.org/2000/01/rdf-schema#subClassOf';
+  // XSD datatypes.
+  const XSD_INTEGER         = 'http://www.w3.org/2001/XMLSchema#integer';
+  const XSD_DOUBLE          = 'http://www.w3.org/2001/XMLSchema#double';
+  const XSD_BOOLEAN         = 'http://www.w3.org/2001/XMLSchema#boolean';
+  const XSD_STRING          = 'http://www.w3.org/2001/XMLSchema#string';
+}
diff --git a/core/modules/rdf/lib/Drupal/rdf/RdfMappingEvents.php b/core/modules/rdf/lib/Drupal/rdf/RdfMappingEvents.php
new file mode 100644
index 0000000..5a7d9a8
--- /dev/null
+++ b/core/modules/rdf/lib/Drupal/rdf/RdfMappingEvents.php
@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * @file
+ * Definition of \Drupal\rdf\RdfMappingEvents.
+ */
+
+namespace Drupal\rdf;
+
+/**
+ * Contains all events thrown while mapping internal and external schemas.
+ */
+final class RdfMappingEvents {
+
+  /**
+   * Maps an array of incoming type URIs to a site schema URI.
+   *
+   * Core will only handle data that uses a site schema URI for the RDF type.
+   * However, other modules can use this event to convert an RDF type from an
+   * externally defined vocabulary to a URI defined in the site's schema.
+   *
+   * @see \Drupal\rdf\RdfMappingManager
+   *
+   * @var string
+   */
+  const MAP_INPUT_TYPES = 'site_schema.map_type';
+
+}
diff --git a/core/modules/rdf/lib/Drupal/rdf/RdfMappingManager.php b/core/modules/rdf/lib/Drupal/rdf/RdfMappingManager.php
new file mode 100644
index 0000000..df34c63
--- /dev/null
+++ b/core/modules/rdf/lib/Drupal/rdf/RdfMappingManager.php
@@ -0,0 +1,169 @@
+<?php
+
+/**
+ * @file
+ * Definition of \Drupal\rdf\RdfMappingManager.
+ */
+
+namespace Drupal\rdf;
+
+use ReflectionClass;
+use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\rdf\MapInputTypesEvent;
+use Drupal\rdf\RdfMappingEvents;
+use Drupal\rdf\SiteSchema\BundleSchema;
+use Drupal\rdf\SiteSchema\SiteSchema;
+use Drupal\rdf\SiteSchema\SchemaConstants;
+
+/**
+ * Manager for mapping internal and external schema terms.
+ */
+class RdfMappingManager {
+
+  /**
+   * The event dispatcher.
+   *
+   * @var \Symfony\Component\EventDispatcher\EventDispatcherInterface
+   */
+  protected $dispatcher;
+
+  /**
+   * The array of site schemas.
+   *
+   * @var array
+   */
+  protected $siteSchemas;
+
+  /**
+   * Constructor.
+   *
+   * @param EventDispatcherInterface $dispatcher
+   */
+  public function __construct(EventDispatcherInterface $dispatcher) {
+    $this->dispatcher = $dispatcher;
+    $this->siteSchemas = array(
+      new SiteSchema(SchemaConstants::CONTENT_STAGING),
+      new SiteSchema(SchemaConstants::SYNDICATION),
+    );
+  }
+
+  /**
+   * Convert an array of RDF type URIs to the corresponding TypedData IDs.
+   *
+   * @param array $inputRdfTypes
+   *   An array of URIs for the type.
+   *
+   * @return array
+   *   An array containing entity_type and bundle.
+   */
+  public function getTypedDataIds($inputRdfTypes) {
+    // Get the cache of site schema types.
+    $siteSchemaTypes = $this->getCacheData('rdf:site_schema:types');
+    // Map the RDF type from the incoming data to an RDF type defined in the
+    // internal site schema.
+    $typeUri = $this->mapInputTypes($inputRdfTypes);
+    // If no site schema URI has been determined, then it's impossible to know
+    // what entity type to create. Throw an exception.
+    if ($typeUri == FALSE) {
+      // @todo Throw exception.
+    }
+    // Use the mapped RDF type URI to get the TypedData API ids the rest of the
+    // system uses (entity type and bundle).
+    return $siteSchemaTypes[$typeUri];
+  }
+
+  /**
+   * Get the cached array of RDF terms and corresponding TypedData Ids.
+   *
+   * @param string $bin
+   *   The cache to get (e.g. rdf:site_schema:types).
+   *
+   * @return array
+   *   The cached data.
+   */
+  protected function getCacheData($bin) {
+    $cache = cache()->get($bin);
+    // If the cache is empty, build it.
+    if ($cache == FALSE) {
+      switch ($bin) {
+        case 'rdf:site_schema:types':
+          $data = $this->buildTypeCache();
+          break;
+      }
+      cache()->set($bin, $data, CacheBackendInterface::CACHE_PERMANENT, 'entity_info');
+      return $data;
+    }
+    return $cache->data;
+  }
+
+  /**
+   * Build the site schema type cache.
+   *
+   * @return array
+   *   An array of TypedData API IDs, keyed by corresponding site schema URI.
+   */
+  protected function buildTypeCache() {
+    $data = array();
+
+    // Type URIs correspond to bundles. Iterate through the bundles to get the
+    // URI and data for them.
+    foreach (entity_get_info() as $entityType => $entityInfo) {
+      // Only content entities are supported currently.
+      // @todo Consider supporting config entities.
+      $reflection = new ReflectionClass($entityInfo['class']);
+      if (!$reflection->implementsInterface('\Drupal\Core\Entity\ContentEntityInterface')) {
+        continue;
+      }
+      foreach ($entityInfo['bundles'] as $bundle => $bundleInfo) {
+        // Get a type URI for the bundle in each of the defined schemas.
+        foreach ($this->siteSchemas as $schema) {
+          $bundleSchema = new BundleSchema($schema, $entityType, $bundle);
+          $bundleUri = $bundleSchema->getUri();
+          $data[$bundleUri] = array(
+            'entity_type' => $entityType,
+            'bundle' => $bundle,
+          );
+        }
+      }
+    }
+    return $data;
+  }
+
+  /**
+   * Map an array of incoming URIs to an internal site schema URI.
+   *
+   * @param array $inputRdfTypes
+   *   An array of RDF type URIs.
+   *
+   * @return string
+   *   The corresponding site schema type URI.
+   */
+  protected function mapInputTypes($inputRdfTypes) {
+    // Create the event using the array of incoming RDF type URIs and the cache
+    // of internal site schema URIs.
+    $siteSchemaTypes = $this->getCacheData('rdf:site_schema:types');
+    $typeMap = new MapInputTypesEvent($inputRdfTypes, $siteSchemaTypes);
+
+    // Add the default listener. This doesn't do any mapping, it only sets the
+    // event's site schema URI if one of the incoming RDF types is a site
+    // schema type URI.
+    $this->dispatcher->addListener(RdfMappingEvents::MAP_INPUT_TYPES, function (MapInputTypesEvent $event) {
+      $inputUris = $event->getInputUris();
+      $siteSchemaTypes = $event->getSiteSchemaTypes();
+      foreach ($inputUris as $inputUri) {
+        if (isset($siteSchemaTypes[$inputUri])) {
+          $event->setSiteSchemaUri($inputUri);
+          $event->stopPropagation();
+        }
+      }
+    });
+
+    // Allow other modules to map the incoming type URIs to an internal site
+    // schema type URI. For example, a content deployment module could take
+    // URIs from the staging site's schema and map them to the corresponding
+    // URI in the live site's schema.
+    $this->dispatcher->dispatch(RdfMappingEvents::MAP_INPUT_TYPES, $typeMap);
+
+    return $typeMap->getSiteSchemaUri();
+  }
+}
diff --git a/core/modules/rdf/lib/Drupal/rdf/SiteSchema/BundleSchema.php b/core/modules/rdf/lib/Drupal/rdf/SiteSchema/BundleSchema.php
new file mode 100644
index 0000000..4ea9839
--- /dev/null
+++ b/core/modules/rdf/lib/Drupal/rdf/SiteSchema/BundleSchema.php
@@ -0,0 +1,58 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\rdf\BundleSchema.
+ */
+
+namespace Drupal\rdf\SiteSchema;
+
+use Drupal\rdf\RdfConstants;
+use Drupal\rdf\SiteSchema\EntitySchema;
+use Drupal\rdf\SiteSchema\SchemaConstants;
+
+/**
+ * Defines RDF terms corresponding to Drupal bundles.
+ */
+class BundleSchema extends EntitySchema {
+
+  /**
+   * The bundle that this term identifies.
+   *
+   * @var string
+   */
+  protected $bundle;
+
+  /**
+   * Constructor.
+   *
+   * @param \Drupal\rdf\SiteSchema $siteSchema
+   *   The schema the term is defined in.
+   * @param string $entity_type
+   *   The entity type.
+   * @param string $bundle
+   *   The bundle.
+   */
+  public function __construct($siteSchema, $entity_type, $bundle) {
+    parent::__construct($siteSchema, $entity_type);
+    $this->bundle = $bundle;
+  }
+
+  /**
+   * Implements \Drupal\rdf\SiteSchema\SchemaBase::getUri().
+   */
+  public function getUri() {
+    $path = str_replace(array('{entity_type}', '{bundle}'), array($this->entityType, $this->bundle), SchemaConstants::URI_PATTERN_BUNDLE);
+    return $this->siteSchema->getUri() . $path;
+  }
+
+  /**
+   * Overrides \Drupal\rdf\SiteSchema\SchemaBase::getProperties().
+   */
+  public function getProperties() {
+    $properties = parent::getProperties();
+    $properties[RdfConstants::RDFS_SUB_CLASS_OF] = $this->siteSchema->entity($this->entityType)->getUri();
+    return $properties;
+  }
+
+}
diff --git a/core/modules/rdf/lib/Drupal/rdf/SiteSchema/EntitySchema.php b/core/modules/rdf/lib/Drupal/rdf/SiteSchema/EntitySchema.php
new file mode 100644
index 0000000..74d01ac
--- /dev/null
+++ b/core/modules/rdf/lib/Drupal/rdf/SiteSchema/EntitySchema.php
@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\rdf\EntitySchema.
+ */
+
+namespace Drupal\rdf\SiteSchema;
+
+use Drupal\rdf\SiteSchema\SchemaBase;
+use Drupal\rdf\SiteSchema\SchemaConstants;
+
+/**
+ * Defines RDF terms corresponding to Drupal entity types.
+ */
+class EntitySchema extends SchemaBase {
+
+  /**
+   * The entity type that this term identifies.
+   *
+   * @var string
+   */
+  protected $entityType;
+
+  /**
+   * Constructor.
+   *
+   * @param \Drupal\rdf\SiteSchema $siteSchema
+   *   The schema the term is defined in.
+   * @param string $entity_type
+   *   The entity type.
+   */
+  public function __construct($siteSchema, $entity_type) {
+    parent::__construct($siteSchema);
+    $this->entityType = $entity_type;
+  }
+
+  /**
+   * Implements \Drupal\rdf\SiteSchema\SchemaBase::getUri().
+   */
+  public function getUri() {
+    $path = str_replace('{entity_type}', $this->entityType , SchemaConstants::URI_PATTERN_ENTITY);
+    return $this->siteSchema->getUri() . $path;
+  }
+
+  /**
+   * Overrides \Drupal\rdf\SiteSchema\SchemaBase::getProperties().
+   */
+  public function getProperties() {
+    $properties = parent::getProperties();
+    return $properties;
+  }
+
+}
diff --git a/core/modules/rdf/lib/Drupal/rdf/SiteSchema/SchemaBase.php b/core/modules/rdf/lib/Drupal/rdf/SiteSchema/SchemaBase.php
new file mode 100644
index 0000000..7c116f2
--- /dev/null
+++ b/core/modules/rdf/lib/Drupal/rdf/SiteSchema/SchemaBase.php
@@ -0,0 +1,57 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\rdf\SchemaBase.
+ */
+
+namespace Drupal\rdf\SiteSchema;
+
+use Drupal\rdf\RdfConstants;
+
+/**
+ * Base class to define an RDF term in a schema.
+ */
+abstract class SchemaBase {
+
+  /**
+   * The schema in which this term is defined.
+   *
+   * @var \Drupal\rdf\RdfSiteSchema
+   */
+  protected $siteSchema;
+
+  /**
+   * Constructor.
+   *
+   * @param \Drupal\rdf\SiteSchemaNamespace $ns
+   *   The namespace.
+   */
+  public function __construct($siteSchema) {
+    $this->siteSchema = $siteSchema;
+  }
+
+  /**
+   * Get the term properties.
+   *
+   * @return array
+   *   An array of properties for this term, keyed by URI.
+   */
+  public function getProperties() {
+    return array(
+      RdfConstants::RDFS_IS_DEFINED_BY => $this->siteSchema->getUri(),
+    );
+  }
+
+  /**
+   * Get the URI of the term.
+   *
+   * Implementations of this method will use the URI patterns defined in
+   * SchemaConstants and replace placeholders with actual values.
+   *
+   * @return string
+   *   The URI of the term.
+   */
+  abstract public function getUri();
+
+}
diff --git a/core/modules/rdf/lib/Drupal/rdf/SiteSchema/SchemaConstants.php b/core/modules/rdf/lib/Drupal/rdf/SiteSchema/SchemaConstants.php
new file mode 100644
index 0000000..95c1f9a
--- /dev/null
+++ b/core/modules/rdf/lib/Drupal/rdf/SiteSchema/SchemaConstants.php
@@ -0,0 +1,20 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\rdf\SiteSchema\SchemaConstants
+ */
+
+namespace Drupal\rdf\SiteSchema;
+
+/**
+ * Defines constants for the paths of terms defined in site-generated schemas.
+ */
+abstract class SchemaConstants {
+  // Site schema paths.
+  const CONTENT_STAGING = 'site-schema/content-staging/';
+  const SYNDICATION     = 'site-schema/syndication/';
+  // Term URI patterns.
+  const URI_PATTERN_ENTITY = '{entity_type}';
+  const URI_PATTERN_BUNDLE = '{entity_type}/{bundle}';
+}
diff --git a/core/modules/rdf/lib/Drupal/rdf/SiteSchema/SchemaController.php b/core/modules/rdf/lib/Drupal/rdf/SiteSchema/SchemaController.php
new file mode 100644
index 0000000..4e55ad3
--- /dev/null
+++ b/core/modules/rdf/lib/Drupal/rdf/SiteSchema/SchemaController.php
@@ -0,0 +1,50 @@
+<?
+
+/**
+ * @file
+ * Definition of Drupal\rdf\SchemaController.
+ */
+
+namespace Drupal\rdf\SiteSchema;
+
+use Drupal\rdf\SiteSchema\SiteSchema;
+use Drupal\rdf\SiteSchema\SchemaConstants;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+
+/**
+ * Resource controller for displaying entity schemas.
+ */
+class SchemaController {
+
+  /**
+   * Responds to a schema request for a bundle of a given entity type.
+   *
+   * @param string $entity_type
+   *   The entity type.
+   * @param string $bundle
+   *   The entity bundle.
+   * @param string $schema_path
+   *   The relative base path for the schema.
+   *
+   * @return \Symfony\Component\HttpFoundation\Response
+   *   The response object.
+   *
+   * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
+   */
+  public function bundle($entity_type, $bundle, $schema_path) {
+    if (!$entity_info = entity_get_info($entity_type)) {
+      throw new NotFoundHttpException(t('Entity type @entity_type not found', array('@entity_type' => $entity_type)));
+    }
+    if (!array_key_exists($bundle, $entity_info['bundles'])) {
+      throw new NotFoundHttpException(t('Bundle @bundle not found', array('@bundle' => $bundle)));
+    }
+
+    $serializer = drupal_container()->get('serializer');
+    $siteSchema = new SiteSchema($schema_path);
+    // @todo Remove hard-coded mimetype once we have proper conneg.
+    $content = $serializer->serialize($siteSchema->bundle($entity_type, $bundle), 'jsonld');
+    return new Response($content, 200, array('Content-type' => 'application/json'));
+  }
+
+}
diff --git a/core/modules/rdf/lib/Drupal/rdf/SiteSchema/SiteSchema.php b/core/modules/rdf/lib/Drupal/rdf/SiteSchema/SiteSchema.php
new file mode 100644
index 0000000..3510591
--- /dev/null
+++ b/core/modules/rdf/lib/Drupal/rdf/SiteSchema/SiteSchema.php
@@ -0,0 +1,70 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\rdf\SiteSchema.
+ */
+
+namespace Drupal\rdf\SiteSchema;
+
+use Drupal\rdf\SiteSchema\BundleSchema;
+use Drupal\rdf\SiteSchema\EntitySchema;
+use Drupal\rdf\SiteSchema\SchemaConstants;
+
+/**
+ * Defines a site-generated schema.
+ */
+class SiteSchema {
+
+  /**
+   * The relative base path of the schema.
+   *
+   * @var string
+   */
+  public $schemaPath;
+
+  /**
+   * Constructor.
+   *
+   * @param string $schemaPath
+   */
+  public function __construct($schemaPath) {
+    $this->schemaPath = $schemaPath;
+  }
+
+  /**
+   * Get an entity's term definition in this vocabulary.
+   */
+  public function entity($entity_type) {
+    return new EntitySchema($this, $entity_type);
+  }
+
+  /**
+   * Get a bundle's term definition in this vocabulary.
+   */
+  public function bundle($entity_type, $bundle) {
+    return new BundleSchema($this, $entity_type, $bundle);
+  }
+
+  /**
+   * Get the URI of the schema.
+   *
+   * @return string
+   *   The URI of the schema.
+   */
+  public function getUri() {
+    return url($this->schemaPath, array('absolute' => TRUE));
+  }
+
+  /**
+   * Get the routes for the types of terms defined in this schema.
+   *
+   * @return array
+   *   An array of route patterns, keyed by controller method name.
+   */
+  public function getRoutes() {
+    return array(
+      'bundle' => $this->schemaPath . SchemaConstants::URI_PATTERN_BUNDLE,
+    );
+  }
+}
diff --git a/core/modules/rdf/lib/Drupal/rdf/Tests/SiteSchemaTest.php b/core/modules/rdf/lib/Drupal/rdf/Tests/SiteSchemaTest.php
new file mode 100644
index 0000000..a23a03c
--- /dev/null
+++ b/core/modules/rdf/lib/Drupal/rdf/Tests/SiteSchemaTest.php
@@ -0,0 +1,55 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\rdf\Tests\SiteSchemaTest.
+ */
+
+namespace Drupal\rdf\Tests;
+
+use Drupal\rdf\SiteSchema\BundleSchema;
+use Drupal\rdf\SiteSchema\SiteSchema;
+use Drupal\rdf\SiteSchema\SchemaConstants;
+use Drupal\simpletest\WebTestBase;
+
+/**
+ * Tests for RDF namespaces XML serialization.
+ */
+class SiteSchemaTest extends WebTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('rdf', 'entity_test');
+
+  public static function getInfo() {
+    return array(
+      'name' => 'RDF site schema test',
+      'description' => 'Confirm that site-generated schemas are created for entity, bundle, field, and field property.',
+      'group' => 'RDF',
+    );
+  }
+
+  /**
+   * Tests site-generated schema.
+   */
+  function testSiteSchema() {
+    $entityType = $bundle = 'entity_test';
+    $schema = new SiteSchema(SchemaConstants::SYNDICATION);
+    $schemaPath = 'site-schema/syndication/';
+
+    // Bundle.
+    $bundleSchema = $schema->bundle($entityType, $bundle);
+    $bundleUri = url("$schemaPath$entityType/$bundle", array('absolute' => TRUE));
+    $bundleProperties = array(
+      "http://www.w3.org/2000/01/rdf-schema#isDefinedBy" => url($schemaPath, array('absolute' => TRUE)),
+      "http://www.w3.org/2000/01/rdf-schema#subClassOf" => url("$schemaPath$entityType", array('absolute' => TRUE)),
+    );
+
+    $this->assertEqual($bundleSchema->getUri(), $bundleUri, 'Bundle term URI is generated correctly.');
+    $this->assertEqual($bundleSchema->getProperties(), $bundleProperties, 'Bundle term properties are generated correctly.');
+  }
+
+}
diff --git a/index.php b/index.php
index 98bcddb..45fc540 100644
--- a/index.php
+++ b/index.php
@@ -13,6 +13,7 @@
 
 use Drupal\Core\DrupalKernel;
 use Symfony\Component\HttpFoundation\Request;
+use Drupal\rdf\RdfMappingManager;
 
 /**
  * Root directory of Drupal installation.
@@ -37,6 +38,8 @@
 
 // Create a request object from the HTTPFoundation.
 $request = Request::createFromGlobals();
+$mapper = drupal_container()->get('rdf.site_schema.mapping_manager');
+$ids = $mapper->getTypedDataIds(array('http://d8.l/site-schema/content-staging/node/article'));
 $response = $kernel->handle($request)->prepare($request)->send();
 
 $kernel->terminate($request, $response);