diff --git a/src/Doctrine/ODM/OrientDB/Configuration.php b/src/Doctrine/ODM/OrientDB/Configuration.php
new file mode 100644
index 0000000..722a40f
--- /dev/null
+++ b/src/Doctrine/ODM/OrientDB/Configuration.php
@@ -0,0 +1,155 @@
+<?php
+
+namespace Doctrine\ODM\OrientDB;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+use Doctrine\Common\Annotations\AnnotationRegistry;
+use Doctrine\Common\Annotations\CachedReader;
+use Doctrine\Common\Annotations\SimpleAnnotationReader;
+use Doctrine\Common\Cache\ArrayCache;
+use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
+use Doctrine\OrientDB\Binding\BindingInterface;
+
+class Configuration
+{
+    /**
+     * @var BindingInterface
+     */
+    protected $binding;
+
+    /**
+     * @var string
+     */
+    protected $classMetadataFactoryName = 'Doctrine\ODM\OrientDB\Mapper\ClassMetadata\Factory';
+
+    /**
+     * @var string
+     */
+    protected $defaultRepositoryClassName = 'Doctrine\ODM\OrientDB\Repository';
+
+    /**
+     * @var MappingDriver
+     */
+    protected $metadataDriver;
+
+    /**
+     * Set the metadata driver
+     *
+     * @param MappingDriver $mappingDriver
+     * @return void
+     *
+     * @todo Force parameter to be a Closure to ensure lazy evaluation
+     * (as soon as a metadata cache is in effect, the driver never needs to initialize).
+     */
+    public function setMetadataDriver(MappingDriver $mappingDriver)
+    {
+        $this->metadataDriver = $mappingDriver;
+    }
+
+    /**
+     * Get the metadata driver
+     *
+     * @return MappingDriver
+     */
+    public function getMetadataDriver()
+    {
+        return $this->metadataDriver;
+    }
+
+    /**
+     * Set binding
+     *
+     * @param BindingInterface $binding
+     */
+    public function setBinding(BindingInterface $binding)
+    {
+        $this->binding = $binding;
+    }
+
+    /**
+     * Get bindung
+     *
+     * @return BindingInterface
+     */
+    public function getBinding()
+    {
+        return $this->binding;
+    }
+
+    /**
+     * Adds a new default annotation driver with a correctly configured annotation reader. If $useSimpleAnnotationReader
+     * is true, the notation `@Entity` will work, otherwise, the notation `@ODM\Entity` will be supported.
+     *
+     * @param array $paths
+     * @param bool $useSimpleAnnotationReader
+     *
+     * @return AnnotationDriver
+     */
+    public function newDefaultAnnotationDriver($paths = array(), $useSimpleAnnotationReader = true)
+    {
+        /** @todo update this */
+        AnnotationRegistry::registerFile(__DIR__ . '/Mapping/Driver/DoctrineAnnotations.php');
+
+        if ($useSimpleAnnotationReader) {
+            // Register the ORM Annotations in the AnnotationRegistry
+            $reader = new SimpleAnnotationReader();
+            $reader->addNamespace('Doctrine\ODM\OrientDB\Mapper'); /* @todo rename directory to Mapping */
+            $cachedReader = new CachedReader($reader, new ArrayCache());
+
+            return new AnnotationDriver($cachedReader, (array) $paths); /* @todo write class */
+        }
+
+        return new AnnotationDriver(
+            new CachedReader(new AnnotationReader(), new ArrayCache()),
+            (array) $paths
+        );
+    }
+
+    /**
+     * Sets a class metadata factory.
+     *
+     * @param string $cmfName
+     * @return void
+     */
+    public function setClassMetadataFactoryName($classMetadataFactoryName)
+    {
+        $this->classMetadataFactoryName = $classMetadataFactoryName;
+    }
+
+    /**
+     * Get class metadata factory name
+     *
+     * @return string
+     */
+    public function getClassMetadataFactoryName()
+    {
+        return $this->classMetadataFactoryName;
+    }
+
+    /**
+     * Set default repository class
+     *
+     * @param string $className
+     * @return void
+     * @throws ODMException If not is a \Doctrine\Common\Persistence\ObjectRepository
+     */
+    public function setDefaultRepositoryClassName($className)
+    {
+        $reflectionClass = new \ReflectionClass($className);
+
+        if ( ! $reflectionClass->implementsInterface('Doctrine\Common\Persistence\ObjectRepository')) {
+            throw ODMException::invalidDocumentRepository($className);
+        }
+        $this->defaultRepositoryClassName = $className;
+    }
+
+    /**
+     * Get default repository class.
+     *
+     * @return string
+     */
+    public function getDefaultRepositoryClassName()
+    {
+        return $this->defaultRepositoryClassName;
+    }
+}
diff --git a/src/Doctrine/ODM/OrientDB/Events.php b/src/Doctrine/ODM/OrientDB/Events.php
new file mode 100644
index 0000000..20b252a
--- /dev/null
+++ b/src/Doctrine/ODM/OrientDB/Events.php
@@ -0,0 +1,145 @@
+<?php
+
+namespace Doctrine\ODM\OrientDB;
+
+/**
+ * Container for all ODM events.
+ *
+ * This class cannot be instantiated.
+ */
+final class Events
+{
+    private function __construct() {}
+
+    /**
+     * The preRemove event occurs for a given document before the respective
+     * Manager remove operation for that document is executed.
+     *
+     * This is an document lifecycle event.
+     *
+     * @var string
+     */
+    const preRemove = 'preRemove';
+
+    /**
+     * The postRemove event occurs for an document after the document has
+     * been deleted. It will be invoked after the database delete operations.
+     *
+     * This is an document lifecycle event.
+     *
+     * @var string
+     */
+    const postRemove = 'postRemove';
+
+    /**
+     * The prePersist event occurs for a given document before the respective
+     * Manager persist operation for that document is executed.
+     *
+     * This is an document lifecycle event.
+     *
+     * @var string
+     */
+    const prePersist = 'prePersist';
+
+    /**
+     * The postPersist event occurs for an document after the document has
+     * been made persistent. It will be invoked after the database insert operations.
+     * Generated primary key values are available in the postPersist event.
+     *
+     * This is an document lifecycle event.
+     *
+     * @var string
+     */
+    const postPersist = 'postPersist';
+
+    /**
+     * The preUpdate event occurs before the database update operations to
+     * document data.
+     *
+     * This is an document lifecycle event.
+     *
+     * @var string
+     */
+    const preUpdate = 'preUpdate';
+
+    /**
+     * The postUpdate event occurs after the database update operations to
+     * document data.
+     *
+     * This is an document lifecycle event.
+     *
+     * @var string
+     */
+    const postUpdate = 'postUpdate';
+
+    /**
+     * The preLoad event occurs for a document before the document has been loaded
+     * into the current Manager from the database or before the refresh operation
+     * has been applied to it.
+     *
+     * This is a document lifecycle event.
+     *
+     * @var string
+     */
+    const preLoad = 'preLoad';
+
+    /**
+     * The postLoad event occurs for a document after the document has been loaded
+     * into the current Manager from the database or after the refresh operation
+     * has been applied to it.
+     *
+     * Note that the postLoad event occurs for an document before any associations have been
+     * initialized. Therefore it is not safe to access associations in a postLoad callback
+     * or event handler.
+     *
+     * This is a document lifecycle event.
+     *
+     * @var string
+     */
+    const postLoad = 'postLoad';
+
+    /**
+     * The loadClassMetadata event occurs after the mapping metadata for a class
+     * has been loaded from a mapping source (annotations/xml/yaml).
+     *
+     * @var string
+     */
+    const loadClassMetadata = 'loadClassMetadata';
+
+    /**
+     * The preFlush event occurs when the Manager#flush() operation is invoked,
+     * but before any changes to managed documents have been calculated. This event is
+     * always raised right after Manager#flush() call.
+     */
+    const preFlush = 'preFlush';
+
+    /**
+     * The onFlush event occurs when the Manager#flush() operation is invoked,
+     * after any changes to managed documents have been determined but before any
+     * actual database operations are executed. The event is only raised if there is
+     * actually something to do for the underlying UnitOfWork. If nothing needs to be done,
+     * the onFlush event is not raised.
+     *
+     * @var string
+     */
+    const onFlush = 'onFlush';
+
+    /**
+     * The postFlush event occurs when the Manager#flush() operation is invoked and
+     * after all actual database operations are executed successfully. The event is only raised if there is
+     * actually something to do for the underlying UnitOfWork. If nothing needs to be done,
+     * the postFlush event is not raised. The event won't be raised if an error occurs during the
+     * flush operation.
+     *
+     * @var string
+     */
+    const postFlush = 'postFlush';
+
+    /**
+     * The onClear event occurs when the Manager#clear() operation is invoked,
+     * after all references to documents have been removed from the unit of work.
+     *
+     * @var string
+     */
+    const onClear = 'onClear';
+}
diff --git a/src/Doctrine/ODM/OrientDB/Manager.php b/src/Doctrine/ODM/OrientDB/Manager.php
index 9da0dee..9287e7f 100644
--- a/src/Doctrine/ODM/OrientDB/Manager.php
+++ b/src/Doctrine/ODM/OrientDB/Manager.php
@@ -21,18 +21,18 @@
 
 namespace Doctrine\ODM\OrientDB;
 
+use Doctrine\Common\EventManager;
+use Doctrine\Common\Persistence\Mapping\ClassMetadataFactory as MetadataFactory;
+use Doctrine\Common\Persistence\ObjectManager;
+use Doctrine\ODM\OrientDB\Caster\CastingMismatchException;
 use Doctrine\ODM\OrientDB\Mapper;
+use Doctrine\ODM\OrientDB\Mapper\ClassMetadata\Factory as ClassMetadataFactory;
 use Doctrine\ODM\OrientDB\Mapper\Hydration\Result;
 use Doctrine\ODM\OrientDB\Types\Rid;
-use Doctrine\ODM\OrientDB\Caster\CastingMismatchException;
-use Doctrine\ODM\OrientDB\Mapper\ClassMetadata\Factory as ClassMetadataFactory;
 use Doctrine\OrientDB\Exception;
 use Doctrine\OrientDB\Binding\BindingInterface;
 use Doctrine\OrientDB\Query\Query;
-use Doctrine\OrientDB\Query\Command\Select;
 use Doctrine\OrientDB\Query\Validator\Rid as RidValidator;
-use Doctrine\Common\Persistence\ObjectManager;
-use Doctrine\Common\Persistence\Mapping\ClassMetadataFactory as MetadataFactory;
 
 class Manager implements ObjectManager
 {
@@ -40,6 +40,13 @@ class Manager implements ObjectManager
     protected $binding;
     protected $metadataFactory;
 
+    /**
+     * The DocumentRepository instances.
+     *
+     * @var \Doctrine\Common\Persistence\ObjectRepository[]
+     */
+    private $repositories = array();
+
     /**
      * Instatiates a new Mapper, injecting the $mapper that will be used to
      * hydrate record retrieved through the $binding.
@@ -47,12 +54,24 @@ class Manager implements ObjectManager
      * @param   Mapper           $mapper
      * @param   BindingInterface $binding
      * @param   MetadataFactory  $metadataFactory
+     * @param   EventManager     $eventManager
      */
-    public function __construct(Mapper $mapper, BindingInterface $binding, MetadataFactory $metadataFactory = null)
+    public function __construct(Mapper $mapper, BindingInterface $binding, MetadataFactory $metadataFactory = null, EventManager $eventManager = null)
     {
         $this->mapper = $mapper;
         $this->binding = $binding;
         $this->metadataFactory = $metadataFactory ?: new ClassMetadataFactory($mapper);
+        $this->eventManager = $eventManager ?: new EventManager();
+    }
+
+    /**
+     * Gets the EventManager used by the DocumentManager.
+     *
+     * @return EventManager
+     */
+    public function getEventManager()
+    {
+        return $this->eventManager;
     }
 
     /**
@@ -138,7 +157,7 @@ public function find($rid, $fetchPlan = '*:1', $lazy = true)
      * @param   string      $rid
      * @param   mixed       $fetchPlan
      * @return  Proxy\Collection|array
-     * @throws  Doctrine\OrientDB\Binding\InvalidQueryException
+     * @throws  \Doctrine\OrientDB\Binding\InvalidQueryException
      */
     public function findRecords(Array $rids, $fetchPlan = null, $lazy = true)
     {
@@ -163,9 +182,10 @@ public function findRecords(Array $rids, $fetchPlan = null, $lazy = true)
     /**
      * @todo to implement/test
      *
-     * @param \stdClass $object
+     * @param null|object|array $entity
+     * @return void
      */
-    public function flush()
+    public function flush($entity = null)
     {
         throw new \Exception;
     }
@@ -174,7 +194,7 @@ public function flush()
      * Gets the $class Metadata.
      *
      * @param   string $class
-     * @return  Doctrine\Common\Persistence\Mapping\ClassMetadata
+     * @return  \Doctrine\ODM\OrientDb\Mapper\ClassMetadata
      */
     public function getClassMetadata($class)
     {
@@ -199,13 +219,20 @@ public function getMetadataFactory()
      */
     public function getRepository($className)
     {
-        $repositoryClass    = $className . "Repository";
+        if (isset($this->repositories[$className])) {
+            return $this->repositories[$className];
+        }
+        $metadata = $this->getClassMetadata($className);
+        $customRepositoryClassName = $metadata->getRepositoryClassname();
 
-        if (class_exists($repositoryClass)) {
-            return new $repositoryClass($className, $this, $this->getMapper());
+        if (null !== $customRepositoryClassName) {
+            $repository = new $customRepositoryClassName($className, $this, $this->getMapper(), $this->getEventManager());
+        } else {
+            $repository = new Repository($className, $this, $this->getMapper(), $this->getEventManager());
         }
 
-        return new Repository($className, $this, $this->getMapper());
+        $this->repositories[$className] = $repository;
+        return $repository;
     }
 
     /**
diff --git a/src/Doctrine/ODM/OrientDB/Mapper/Annotations/Document.php b/src/Doctrine/ODM/OrientDB/Mapper/Annotations/Document.php
index 8fd51a8..25c4084 100644
--- a/src/Doctrine/ODM/OrientDB/Mapper/Annotations/Document.php
+++ b/src/Doctrine/ODM/OrientDB/Mapper/Annotations/Document.php
@@ -25,6 +25,7 @@
 class Document extends \Doctrine\Common\Annotations\Annotation
 {
     public $class;
+    public $repositoryClass;
 
     /**
      * Given a $Doctrine\OrientDBClass, checks wheter this annotation matches it.
diff --git a/src/Doctrine/ODM/OrientDB/Mapper/Annotations/Reader.php b/src/Doctrine/ODM/OrientDB/Mapper/Annotations/Reader.php
index f67a1d4..cfd9b6c 100644
--- a/src/Doctrine/ODM/OrientDB/Mapper/Annotations/Reader.php
+++ b/src/Doctrine/ODM/OrientDB/Mapper/Annotations/Reader.php
@@ -143,7 +143,7 @@ protected function getReader()
     /**
      * Creates a new instance of a cache provider.
      *
-     * @return Doctrine\Common\Cache\CacheProvider
+     * @return \Doctrine\Common\Cache\CacheProvider
      */
     protected function createCacheProvider()
     {
diff --git a/src/Doctrine/ODM/OrientDB/Mapper/ClassMetadata.php b/src/Doctrine/ODM/OrientDB/Mapper/ClassMetadata.php
index 1b0a919..3568c37 100644
--- a/src/Doctrine/ODM/OrientDB/Mapper/ClassMetadata.php
+++ b/src/Doctrine/ODM/OrientDB/Mapper/ClassMetadata.php
@@ -31,6 +31,14 @@ class ClassMetadata implements DoctrineMetadata
     private $singleAssociations = array('link');
     private $multipleAssociations = array('linklist', 'linkset', 'linkmap');
 
+    /**
+     * The name of the custom repository class used for the document class.
+     * (Optional).
+     *
+     * @var string|null
+     */
+    protected $repositoryClassName;
+
     /**
      * Instantiates a new Metadata for the given $className.
      *
@@ -65,10 +73,31 @@ public function getIdentifier()
         return array('@rid');
     }
 
+    /**
+     * Registers a custom repository class for the document class.
+     *
+     * @param string $mapperClassName  The class name of the custom mapper.
+     */
+    public function setRepositoryClassName($repositoryClassName)
+    {
+        $this->repositoryClassName = $repositoryClassName;
+    }
+
+    /**
+     * Get repository class
+     *
+     * @return string|null
+     */
+    public function getRepositoryClassName()
+    {
+        $document = $this->getMapper()->getClassAnnotation($this->getName());
+        return $document->repositoryClass;
+    }
+
     /**
      * Gets the ReflectionClass instance for this mapped class.
      *
-     * @return ReflectionClass
+     * @return \ReflectionClass
      */
     public function getReflectionClass()
     {
@@ -346,7 +375,7 @@ protected function isValuedAssociation($field, Array $associationTypes)
     /**
      * Returns the mapper associated with this Metadata.
      *
-     * @return Mapper
+     * @return DataMapper
      */
     protected function getMapper()
     {
diff --git a/src/Doctrine/ODM/OrientDB/ODMException.php b/src/Doctrine/ODM/OrientDB/ODMException.php
new file mode 100644
index 0000000..c2e2d6f
--- /dev/null
+++ b/src/Doctrine/ODM/OrientDB/ODMException.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Doctrine\ODM\OrientDB;
+
+use Exception;
+
+/**
+ * Base exception class for all ODM exceptions.
+ */
+class ODMException extends Exception
+{
+    /**
+     * @param string $className
+     *
+     * @return ODMException
+     */
+    public static function invalidDocumentRepository($className)
+    {
+        return new self(
+            'Invalid repository class "' . $className . '". It must be a Doctrine\Common\Persistence\ObjectRepository.'
+        );
+    }
+}
diff --git a/test/Doctrine/ODM/OrientDB/Document/Stub/City.php b/test/Doctrine/ODM/OrientDB/Document/Stub/City.php
index f492925..e720c7e 100644
--- a/test/Doctrine/ODM/OrientDB/Document/Stub/City.php
+++ b/test/Doctrine/ODM/OrientDB/Document/Stub/City.php
@@ -5,7 +5,7 @@
 use Doctrine\ODM\OrientDB\Mapper\Annotations as ODM;
 
 /**
-* @ODM\Document(class="OCity")
+* @ODM\Document(class="OCity", repositoryClass="test\Doctrine\ODM\OrientDB\Document\Stub\CityRepository")
 */
 class City
 {