diff --git a/authorization/src/main/java/org/apache/atlas/authorize/AtlasResourceTypes.java b/authorization/src/main/java/org/apache/atlas/authorize/AtlasResourceTypes.java
index deccf84..925b6b1 100644
--- a/authorization/src/main/java/org/apache/atlas/authorize/AtlasResourceTypes.java
+++ b/authorization/src/main/java/org/apache/atlas/authorize/AtlasResourceTypes.java
@@ -19,5 +19,5 @@
 package org.apache.atlas.authorize;
 
 public enum AtlasResourceTypes {
-    UNKNOWN, ENTITY, TYPE, OPERATION, TAXONOMY, TERM
+    UNKNOWN, ENTITY, TYPE, OPERATION, TAXONOMY, TERM, RELATION
 }
diff --git a/authorization/src/main/java/org/apache/atlas/authorize/simple/AtlasAuthorizationUtils.java b/authorization/src/main/java/org/apache/atlas/authorize/simple/AtlasAuthorizationUtils.java
index 93d988e..bb3157a 100644
--- a/authorization/src/main/java/org/apache/atlas/authorize/simple/AtlasAuthorizationUtils.java
+++ b/authorization/src/main/java/org/apache/atlas/authorize/simple/AtlasAuthorizationUtils.java
@@ -139,6 +139,8 @@
             if (contextPath.contains("/terms")) {
                 resourceTypes.add(AtlasResourceTypes.TERM);
             }
+        } else if (api.startsWith("relation")) {
+            resourceTypes.add(AtlasResourceTypes.RELATION);
         } else {
             LOG.error("Unable to find Atlas Resource corresponding to : {}\nSetting {}"
                     , api, AtlasResourceTypes.UNKNOWN.name());
diff --git a/authorization/src/main/java/org/apache/atlas/authorize/simple/PolicyParser.java b/authorization/src/main/java/org/apache/atlas/authorize/simple/PolicyParser.java
index 7ef49e6..acf7388 100644
--- a/authorization/src/main/java/org/apache/atlas/authorize/simple/PolicyParser.java
+++ b/authorization/src/main/java/org/apache/atlas/authorize/simple/PolicyParser.java
@@ -231,6 +231,8 @@
                     resourceType = AtlasResourceTypes.TAXONOMY;
                 } else if (type.equalsIgnoreCase("TERM")) {
                     resourceType = AtlasResourceTypes.TERM;
+                } else if (type.equalsIgnoreCase("RELATION")) {
+                    resourceType = AtlasResourceTypes.RELATION;
                 } else {
                     Log.warn(type + " is invalid resource please check PolicyStore file");
                     continue;
diff --git a/graphdb/api/src/main/java/org/apache/atlas/repository/graphdb/AtlasGraphQuery.java b/graphdb/api/src/main/java/org/apache/atlas/repository/graphdb/AtlasGraphQuery.java
index bd7b35e..841edf7 100644
--- a/graphdb/api/src/main/java/org/apache/atlas/repository/graphdb/AtlasGraphQuery.java
+++ b/graphdb/api/src/main/java/org/apache/atlas/repository/graphdb/AtlasGraphQuery.java
@@ -60,6 +60,12 @@
      */
     Iterable<AtlasVertex<V, E>> vertices();
 
+    /**
+     * Executes the query and returns the matching edges.
+     * @return
+     */
+    Iterable<AtlasEdge<V, E>> edges();
+
 
     /**
      * Adds a predicate that the returned vertices must have the specified
diff --git a/graphdb/common/src/main/java/org/apache/atlas/repository/graphdb/titan/query/NativeTitanGraphQuery.java b/graphdb/common/src/main/java/org/apache/atlas/repository/graphdb/titan/query/NativeTitanGraphQuery.java
index 662a270..0211ff0 100644
--- a/graphdb/common/src/main/java/org/apache/atlas/repository/graphdb/titan/query/NativeTitanGraphQuery.java
+++ b/graphdb/common/src/main/java/org/apache/atlas/repository/graphdb/titan/query/NativeTitanGraphQuery.java
@@ -19,6 +19,7 @@
 
 import java.util.Collection;
 
+import org.apache.atlas.repository.graphdb.AtlasEdge;
 import org.apache.atlas.repository.graphdb.AtlasGraphQuery.ComparisionOperator;
 import org.apache.atlas.repository.graphdb.AtlasVertex;
 
@@ -39,6 +40,11 @@
      */
     Iterable<AtlasVertex<V, E>> vertices();
 
+    /**
+     * Executes the graph query.
+     * @return
+     */
+    Iterable<AtlasEdge<V, E>> edges();
 
     /**
      * Adds an in condition to the query.
diff --git a/graphdb/common/src/main/java/org/apache/atlas/repository/graphdb/titan/query/TitanGraphQuery.java b/graphdb/common/src/main/java/org/apache/atlas/repository/graphdb/titan/query/TitanGraphQuery.java
index 056088c..0077a21 100644
--- a/graphdb/common/src/main/java/org/apache/atlas/repository/graphdb/titan/query/TitanGraphQuery.java
+++ b/graphdb/common/src/main/java/org/apache/atlas/repository/graphdb/titan/query/TitanGraphQuery.java
@@ -22,6 +22,7 @@
 import java.util.List;
 import java.util.Set;
 
+import org.apache.atlas.repository.graphdb.AtlasEdge;
 import org.apache.atlas.repository.graphdb.AtlasGraph;
 import org.apache.atlas.repository.graphdb.AtlasGraphQuery;
 import org.apache.atlas.repository.graphdb.AtlasVertex;
@@ -121,8 +122,10 @@
 
     @Override
     public Iterable<AtlasVertex<V, E>> vertices() {
-        LOG.debug("Executing: ");
-        LOG.debug(queryCondition.toString());
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("Executing: " + queryCondition.toString());
+        }
+
         //compute the overall result by unioning the results from all of the
         //AndConditions together.
         Set<AtlasVertex<V, E>> result = new HashSet<>();
@@ -136,6 +139,24 @@
     }
 
     @Override
+    public Iterable<AtlasEdge<V, E>> edges() {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("Executing: " + queryCondition.toString());
+        }
+
+        //compute the overall result by unioning the results from all of the
+        //AndConditions together.
+        Set<AtlasEdge<V, E>> result = new HashSet<>();
+        for(AndCondition andExpr : queryCondition.getAndTerms()) {
+            NativeTitanGraphQuery<V, E> andQuery = andExpr.create(getQueryFactory());
+            for(AtlasEdge<V, E> edge : andQuery.edges()) {
+                result.add(edge);
+            }
+        }
+        return result;
+    }
+
+    @Override
     public AtlasGraphQuery<V, E> has(String propertyKey, ComparisionOperator operator,
             Object value) {
         queryCondition.andWith(new HasPredicate(propertyKey, operator, value));
diff --git a/graphdb/titan0/src/main/java/org/apache/atlas/repository/graphdb/titan0/query/NativeTitan0GraphQuery.java b/graphdb/titan0/src/main/java/org/apache/atlas/repository/graphdb/titan0/query/NativeTitan0GraphQuery.java
index 5ad176b..7ec6ffe 100644
--- a/graphdb/titan0/src/main/java/org/apache/atlas/repository/graphdb/titan0/query/NativeTitan0GraphQuery.java
+++ b/graphdb/titan0/src/main/java/org/apache/atlas/repository/graphdb/titan0/query/NativeTitan0GraphQuery.java
@@ -19,6 +19,7 @@
 
 import java.util.Collection;
 
+import org.apache.atlas.repository.graphdb.AtlasEdge;
 import org.apache.atlas.repository.graphdb.AtlasGraphQuery.ComparisionOperator;
 import org.apache.atlas.repository.graphdb.AtlasVertex;
 import org.apache.atlas.repository.graphdb.titan.query.NativeTitanGraphQuery;
@@ -54,6 +55,11 @@
         return graph.wrapVertices(it);
     }
 
+    @Override
+    public Iterable<AtlasEdge<Titan0Vertex, Titan0Edge>> edges() {
+        Iterable it = query.edges();
+        return graph.wrapEdges(it);
+    }
 
     @Override
     public void in(String propertyName, Collection<?> values) {
diff --git a/graphdb/titan1/src/main/java/org/apache/atlas/repository/graphdb/titan1/Titan1Graph.java b/graphdb/titan1/src/main/java/org/apache/atlas/repository/graphdb/titan1/Titan1Graph.java
index e829d91..ffb6b37 100644
--- a/graphdb/titan1/src/main/java/org/apache/atlas/repository/graphdb/titan1/Titan1Graph.java
+++ b/graphdb/titan1/src/main/java/org/apache/atlas/repository/graphdb/titan1/Titan1Graph.java
@@ -384,11 +384,6 @@
         return expr;
     }
 
-    public Iterable<AtlasEdge<Titan1Vertex, Titan1Edge>> wrapEdges(Iterator<Edge> it) {
-        Iterable<Edge> iterable = new IteratorToIterableAdapter<Edge>(it);
-        return wrapEdges(iterable);
-    }
-
     public Iterable<AtlasVertex<Titan1Vertex, Titan1Edge>> wrapVertices(Iterator<? extends Vertex> it) {
         Iterable<? extends Vertex> iterable = new IteratorToIterableAdapter<>(it);
         return wrapVertices(iterable);
@@ -406,15 +401,21 @@
 
     }
 
-    public Iterable<AtlasEdge<Titan1Vertex, Titan1Edge>> wrapEdges(Iterable<Edge> it) {
-        Iterable<Edge> result = (Iterable<Edge>) it;
-        return Iterables.transform(result, new Function<Edge, AtlasEdge<Titan1Vertex, Titan1Edge>>() {
+    public Iterable<AtlasEdge<Titan1Vertex, Titan1Edge>> wrapEdges(Iterator<? extends Edge> it) {
+        Iterable<? extends Edge> iterable = new IteratorToIterableAdapter<>(it);
+        return wrapEdges(iterable);
+    }
+
+    public Iterable<AtlasEdge<Titan1Vertex, Titan1Edge>> wrapEdges(Iterable<? extends Edge> it) {
+
+        return Iterables.transform(it, new Function<Edge, AtlasEdge<Titan1Vertex, Titan1Edge>>() {
 
             @Override
             public AtlasEdge<Titan1Vertex, Titan1Edge> apply(Edge input) {
                 return GraphDbObjectFactory.createEdge(Titan1Graph.this, input);
             }
         });
+
     }
 
     @Override
diff --git a/graphdb/titan1/src/main/java/org/apache/atlas/repository/graphdb/titan1/query/NativeTitan1GraphQuery.java b/graphdb/titan1/src/main/java/org/apache/atlas/repository/graphdb/titan1/query/NativeTitan1GraphQuery.java
index 9dc175b..1ca900d 100644
--- a/graphdb/titan1/src/main/java/org/apache/atlas/repository/graphdb/titan1/query/NativeTitan1GraphQuery.java
+++ b/graphdb/titan1/src/main/java/org/apache/atlas/repository/graphdb/titan1/query/NativeTitan1GraphQuery.java
@@ -19,6 +19,8 @@
 
 import java.util.Collection;
 
+import com.thinkaurelius.titan.core.TitanEdge;
+import org.apache.atlas.repository.graphdb.AtlasEdge;
 import org.apache.atlas.repository.graphdb.AtlasGraphQuery.ComparisionOperator;
 import org.apache.atlas.repository.graphdb.AtlasVertex;
 import org.apache.atlas.repository.graphdb.titan.query.NativeTitanGraphQuery;
@@ -53,6 +55,12 @@
     }
 
     @Override
+    public Iterable<AtlasEdge<Titan1Vertex, Titan1Edge>> edges() {
+        Iterable<TitanEdge> it = query.edges();
+        return graph.wrapEdges(it);
+    }
+
+    @Override
     public void in(String propertyName, Collection<? extends Object> values) {
         query.has(propertyName, Contain.IN, values);
 
diff --git a/intg/src/main/java/org/apache/atlas/AtlasErrorCode.java b/intg/src/main/java/org/apache/atlas/AtlasErrorCode.java
index 6c33f40..e8971a8 100644
--- a/intg/src/main/java/org/apache/atlas/AtlasErrorCode.java
+++ b/intg/src/main/java/org/apache/atlas/AtlasErrorCode.java
@@ -79,6 +79,8 @@
     RELATIONSHIPDEF_AGGREGATION_NO_CONTAINER(400,  "ATLAS-400-00-032", "AGGREGATION relationshipDef {0} creation attempted without an end specifying isContainer"),
     RELATIONSHIPDEF_COMPOSITION_SET_CONTAINER(400,  "ATLAS-400-00-033", "COMPOSITION relationshipDef {0} cannot have a SET cardinality and be a container"),
     RELATIONSHIPDEF_LIST_ON_END(400,  "ATLAS-400-00-034", "relationshipDef {0} cannot have a LIST cardinality on an end"),
+    RELATIONSHIPDEF_INVALID_END_TYPE(400,  "ATLAS-400-00-035", "relationshipDef {0} has invalid end type {1}"),
+    INVALID_RELATIONSHIP_END_TYPE(400, "ATLAS-400-00-036", "invalid end type for relationship {0}: expected {1}, found {2}"),
     // All Not found enums go here
     TYPE_NAME_NOT_FOUND(404, "ATLAS-404-00-001", "Given typename {0} was invalid"),
     TYPE_GUID_NOT_FOUND(404, "ATLAS-404-00-002", "Given type guid {0} was invalid"),
@@ -90,11 +92,13 @@
     INSTANCE_BY_UNIQUE_ATTRIBUTE_NOT_FOUND(404, "ATLAS-404-00-009", "Instance {0} with unique attribute {1} does not exist"),
     REFERENCED_ENTITY_NOT_FOUND(404, "ATLAS-404-00-00A", "Referenced entity {0} is not found"),
     INSTANCE_NOT_FOUND(404, "ATLAS-404-00-00B", "Given instance is invalid/not found: {0}"),
+    RELATIONSHIP_GUID_NOT_FOUND(404, "ATLAS-404-00-00C", "Given relationship guid {0} is invalid/not found"),
 
      // All data conflict errors go here
     TYPE_ALREADY_EXISTS(409, "ATLAS-409-00-001", "Given type {0} already exists"),
     TYPE_HAS_REFERENCES(409, "ATLAS-409-00-002", "Given type {0} has references"),
     INSTANCE_ALREADY_EXISTS(409, "ATLAS-409-00-003", "failed to update entity: {0}"),
+    RELATIONSHIP_ALREADY_EXISTS(409, "ATLAS-409-00-004", "relationship {0} already exists between entities {1} and {2}"),
 
      // All internal errors go here
     INTERNAL_ERROR(500, "ATLAS-500-00-001", "Internal server error {0}"),
diff --git a/intg/src/main/java/org/apache/atlas/model/instance/AtlasRelationship.java b/intg/src/main/java/org/apache/atlas/model/instance/AtlasRelationship.java
new file mode 100644
index 0000000..8d2e7ec
--- /dev/null
+++ b/intg/src/main/java/org/apache/atlas/model/instance/AtlasRelationship.java
@@ -0,0 +1,243 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.model.instance;
+
+import org.apache.atlas.model.typedef.AtlasRelationshipDef;
+import org.codehaus.jackson.annotate.JsonAutoDetect;
+import org.codehaus.jackson.annotate.JsonIgnore;
+import org.codehaus.jackson.annotate.JsonIgnoreProperties;
+import org.codehaus.jackson.map.annotate.JsonSerialize;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlRootElement;
+import java.io.Serializable;
+import java.util.Date;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicLong;
+
+import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.NONE;
+import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.PUBLIC_ONLY;
+
+
+/**
+ * Atlas relationship instance.
+ */
+@JsonAutoDetect(getterVisibility=PUBLIC_ONLY, setterVisibility=PUBLIC_ONLY, fieldVisibility=NONE)
+@JsonSerialize(include=JsonSerialize.Inclusion.NON_NULL)
+@JsonIgnoreProperties(ignoreUnknown=true)
+@XmlRootElement
+@XmlAccessorType(XmlAccessType.PROPERTY)
+public class AtlasRelationship extends AtlasStruct implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    private String        guid       = null;
+    private AtlasObjectId end1       = null;
+    private AtlasObjectId end2       = null;
+    private Status        status     = Status.ACTIVE;
+    private String        createdBy  = null;
+    private String        updatedBy  = null;
+    private Date          createTime = null;
+    private Date          updateTime = null;
+    private Long          version    = 0L;
+
+    public enum Status { ACTIVE, DELETED }
+
+    @JsonIgnore
+    private static AtomicLong s_nextId = new AtomicLong(System.nanoTime());
+
+    public AtlasRelationship() {
+        super();
+
+        init();
+    }
+
+    public AtlasRelationship(String typeName) {
+        this(typeName, null);
+    }
+
+    public AtlasRelationship(String typeName, Map<String, Object> attributes) {
+        super(typeName, attributes);
+
+        init();
+    }
+
+    public AtlasRelationship(String typeName, AtlasObjectId end1, AtlasObjectId end2) {
+        super(typeName);
+
+        init(nextInternalId(), end1, end2, null, null, null, null, null, 0L);
+    }
+
+    public AtlasRelationship(String typeName, String attrName, Object attrValue) {
+        super(typeName, attrName, attrValue);
+
+        init();
+    }
+
+    public AtlasRelationship(AtlasRelationshipDef relationshipDef) {
+        this(relationshipDef != null ? relationshipDef.getName() : null);
+    }
+
+    public AtlasRelationship(AtlasRelationship other) {
+        super(other);
+
+        if (other != null) {
+            init(other.guid, other.end1, other.end2, other.status, other.createdBy, other.updatedBy,
+                 other.createTime, other.updateTime, other.version);
+        }
+    }
+
+    public String getGuid() {
+        return guid;
+    }
+
+    public void setGuid(String guid) {
+        this.guid = guid;
+    }
+
+    public Status getStatus() {
+        return status;
+    }
+
+    public void setStatus(Status status) {
+        this.status = status;
+    }
+
+    public String getCreatedBy() {
+        return createdBy;
+    }
+
+    public void setCreatedBy(String createdBy) {
+        this.createdBy = createdBy;
+    }
+
+    public String getUpdatedBy() {
+        return updatedBy;
+    }
+
+    public void setUpdatedBy(String updatedBy) {
+        this.updatedBy = updatedBy;
+    }
+
+    public Date getCreateTime() {
+        return createTime;
+    }
+
+    public void setCreateTime(Date createTime) {
+        this.createTime = createTime;
+    }
+
+    public Date getUpdateTime() {
+        return updateTime;
+    }
+
+    public void setUpdateTime(Date updateTime) {
+        this.updateTime = updateTime;
+    }
+
+    public Long getVersion() {
+        return version;
+    }
+
+    public void setVersion(Long version) {
+        this.version = version;
+    }
+
+    public AtlasObjectId getEnd1() { return end1; }
+
+    public void setEnd1(AtlasObjectId end1) { this.end1 = end1; }
+
+    public AtlasObjectId getEnd2() { return end2; }
+
+    public void setEnd2(AtlasObjectId end2) { this.end2 = end2; }
+
+    private static String nextInternalId() {
+        return "-" + Long.toString(s_nextId.getAndIncrement());
+    }
+
+    public String getRelationshipLabel() { return "r:" + super.getTypeName(); }
+
+    private void init() {
+        init(nextInternalId(), null, null, null, null, null, null, null, 0L);
+    }
+
+    private void init(String guid, AtlasObjectId end1, AtlasObjectId end2,
+                      Status status, String createdBy, String updatedBy,
+                      Date createTime, Date updateTime, Long version) {
+        setGuid(guid);
+        setEnd1(end1);
+        setEnd2(end2);
+        setStatus(status);
+        setCreatedBy(createdBy);
+        setUpdatedBy(updatedBy);
+        setCreateTime(createTime);
+        setUpdateTime(updateTime);
+        setVersion(version);
+    }
+
+    @Override
+    public StringBuilder toString(StringBuilder sb) {
+        if (sb == null) {
+            sb = new StringBuilder();
+        }
+
+        sb.append("AtlasRelationship{");
+        super.toString(sb);
+        sb.append("guid='").append(guid).append('\'');
+        sb.append(", end1=").append(end1);
+        sb.append(", end2=").append(end2);
+        sb.append(", status=").append(status);
+        sb.append(", createdBy='").append(createdBy).append('\'');
+        sb.append(", updatedBy='").append(updatedBy).append('\'');
+        dumpDateField(", createTime=", createTime, sb);
+        dumpDateField(", updateTime=", updateTime, sb);
+        sb.append(", version=").append(version);
+        sb.append('}');
+
+        return sb;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) { return true; }
+        if (o == null || getClass() != o.getClass()) { return false; }
+        if (!super.equals(o)) { return false; }
+
+        AtlasRelationship that = (AtlasRelationship) o;
+        return Objects.equals(guid, that.guid)             &&
+               Objects.equals(end1, that.end1)             &&
+               Objects.equals(end2, that.end2)             &&
+               status == that.status                       &&
+               Objects.equals(createdBy, that.createdBy)   &&
+               Objects.equals(updatedBy, that.updatedBy)   &&
+               Objects.equals(createTime, that.createTime) &&
+               Objects.equals(updateTime, that.updateTime) &&
+               Objects.equals(version, that.version);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(super.hashCode(), guid, end1, end2, status, createdBy, updatedBy, createTime, updateTime, version);
+    }
+
+    @Override
+    public String toString() {
+        return toString(new StringBuilder()).toString();
+    }
+}
\ No newline at end of file
diff --git a/intg/src/main/java/org/apache/atlas/model/typedef/AtlasRelationshipEndDef.java b/intg/src/main/java/org/apache/atlas/model/typedef/AtlasRelationshipEndDef.java
index 000d747..34e932e 100644
--- a/intg/src/main/java/org/apache/atlas/model/typedef/AtlasRelationshipEndDef.java
+++ b/intg/src/main/java/org/apache/atlas/model/typedef/AtlasRelationshipEndDef.java
@@ -18,6 +18,7 @@
 package org.apache.atlas.model.typedef;
 
 import org.apache.atlas.model.typedef.AtlasStructDef.AtlasAttributeDef.Cardinality;
+import org.apache.commons.lang.StringUtils;
 import org.codehaus.jackson.annotate.JsonAutoDetect;
 import org.codehaus.jackson.annotate.JsonIgnoreProperties;
 import org.codehaus.jackson.map.annotate.JsonSerialize;
@@ -59,6 +60,10 @@
      * This is the cardinality of the end
      */
     private Cardinality cardinality;
+    /**
+     * legacy edge label name of the endpoint
+     */
+    private String legacyLabel;
 
     /**
      * Base constructor
@@ -92,10 +97,29 @@
      *   - whether the end is a container or not
      */
     public AtlasRelationshipEndDef(String typeName, String name, Cardinality cardinality, boolean isContainer) {
+        this(typeName, name, cardinality, isContainer, null);
+    }
+
+    public AtlasRelationshipEndDef(String typeName, String name, Cardinality cardinality, boolean isContainer, String legacyLabel) {
         setType(typeName);
         setName(name);
         setCardinality(cardinality);
         setIsContainer(isContainer);
+        setLegacyLabel(legacyLabel);
+    }
+
+    /**
+     * Construct using an existing AtlasRelationshipEndDef
+     * @param other
+     */
+    public AtlasRelationshipEndDef(AtlasRelationshipEndDef other) {
+        if (other != null) {
+            setType(other.getType());
+            setName(other.getName());
+            setIsContainer(other.getIsContainer());
+            setCardinality(other.getCardinality());
+            setLegacyLabel(other.getLegacyLabel());
+        }
     }
 
     public void setType(String type) {
@@ -142,18 +166,15 @@
         return this.cardinality;
     }
 
-    /**
-     * Construct using an existing AtlasRelationshipEndDef
-     * @param other
-     */
-    public AtlasRelationshipEndDef(AtlasRelationshipEndDef other) {
-        if (other != null) {
-            setType(other.getType());
-            setName(other.getName());
-            setIsContainer(other.getIsContainer());
-            setCardinality(other.getCardinality());
-        }
-    }
+    public boolean isContainer() { return isContainer; }
+
+    public void setContainer(boolean container) { isContainer = container; }
+
+    public String getLegacyLabel() { return legacyLabel; }
+
+    public void setLegacyLabel(String legacyLabel) {  this.legacyLabel = legacyLabel; }
+
+    public boolean hasLegacyRelation() { return StringUtils.isNotEmpty(getLegacyLabel()) ? true : false; }
 
     public StringBuilder toString(StringBuilder sb) {
         if (sb == null) {
@@ -165,6 +186,7 @@
         sb.append(", name==>'").append(name).append('\'');
         sb.append(", isContainer==>'").append(isContainer).append('\'');
         sb.append(", cardinality==>'").append(cardinality).append('\'');
+        sb.append(", legacyLabel==>'").append(legacyLabel).append('\'');
         sb.append('}');
 
         return sb;
@@ -177,13 +199,17 @@
         if (o == null || getClass() != o.getClass())
             return false;
         AtlasRelationshipEndDef that = (AtlasRelationshipEndDef) o;
-        return Objects.equals(type, that.type) && Objects.equals(name, that.name)
-                && (isContainer == that.isContainer) && (cardinality == that.cardinality);
+
+        return Objects.equals(type, that.type) &&
+               Objects.equals(name, that.name) &&
+               isContainer == that.isContainer &&
+               cardinality == that.cardinality &&
+               Objects.equals(legacyLabel, that.legacyLabel);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(type, getName(), isContainer, cardinality);
+        return Objects.hash(type, getName(), isContainer, cardinality, legacyLabel);
     }
 
     @Override
diff --git a/intg/src/main/java/org/apache/atlas/type/AtlasEntityType.java b/intg/src/main/java/org/apache/atlas/type/AtlasEntityType.java
index 0ff1582..a29f7fb 100644
--- a/intg/src/main/java/org/apache/atlas/type/AtlasEntityType.java
+++ b/intg/src/main/java/org/apache/atlas/type/AtlasEntityType.java
@@ -128,6 +128,10 @@
         return StringUtils.isNotEmpty(entityTypeName) && allSubTypes.contains(entityTypeName);
     }
 
+    public boolean isTypeOrSuperTypeOf(String entityTypeName) {
+        return StringUtils.isNotEmpty(entityTypeName) && typeAndAllSubTypes.contains(entityTypeName);
+    }
+
     public boolean isSubTypeOf(AtlasEntityType entityType) {
         return entityType != null && allSuperTypes.contains(entityType.getTypeName());
     }
diff --git a/intg/src/main/java/org/apache/atlas/type/AtlasRelationshipType.java b/intg/src/main/java/org/apache/atlas/type/AtlasRelationshipType.java
index eb2fc48..296c06c 100644
--- a/intg/src/main/java/org/apache/atlas/type/AtlasRelationshipType.java
+++ b/intg/src/main/java/org/apache/atlas/type/AtlasRelationshipType.java
@@ -35,6 +35,8 @@
     private static final Logger LOG = LoggerFactory.getLogger(AtlasRelationshipType.class);
 
     private final AtlasRelationshipDef relationshipDef;
+    private       AtlasEntityType      end1Type;
+    private       AtlasEntityType      end2Type;
 
     public AtlasRelationshipType(AtlasRelationshipDef relationshipDef) {
         super(relationshipDef);
@@ -55,6 +57,24 @@
     public void resolveReferences(AtlasTypeRegistry typeRegistry) throws AtlasBaseException {
         super.resolveReferences(typeRegistry);
 
+        String end1TypeName = relationshipDef != null && relationshipDef.getEndDef1() != null ? relationshipDef.getEndDef1().getType() : null;
+        String end2TypeName = relationshipDef != null && relationshipDef.getEndDef2() != null ? relationshipDef.getEndDef2().getType() : null;
+
+        AtlasType type1 = typeRegistry.getType(end1TypeName);
+        AtlasType type2 = typeRegistry.getType(end2TypeName);
+
+        if (type1 instanceof AtlasEntityType) {
+            end1Type = (AtlasEntityType)type1;
+        } else {
+            throw new AtlasBaseException(AtlasErrorCode.RELATIONSHIPDEF_INVALID_END_TYPE, getTypeName(), end1TypeName);
+        }
+
+        if (type2 instanceof AtlasEntityType) {
+            end2Type = (AtlasEntityType)type2;
+        } else {
+            throw new AtlasBaseException(AtlasErrorCode.RELATIONSHIPDEF_INVALID_END_TYPE, getTypeName(), end2TypeName);
+        }
+
         validateAtlasRelationshipDef(this.relationshipDef);
     }
 
@@ -81,6 +101,11 @@
 
         return ret;
     }
+
+    public AtlasEntityType getEnd1Type() { return end1Type; }
+
+    public AtlasEntityType getEnd2Type() { return end2Type; }
+
     /**
      * Validate the fields in the the RelationshipType are consistent with respect to themselves.
      * @param type
diff --git a/intg/src/main/java/org/apache/atlas/type/AtlasTypeRegistry.java b/intg/src/main/java/org/apache/atlas/type/AtlasTypeRegistry.java
index aebd4d1..29fae1c 100644
--- a/intg/src/main/java/org/apache/atlas/type/AtlasTypeRegistry.java
+++ b/intg/src/main/java/org/apache/atlas/type/AtlasTypeRegistry.java
@@ -186,6 +186,7 @@
         return registryData.classificationDefs.getTypeByName(name);
     }
 
+    public Collection<AtlasRelationshipDef> getAllRelationshipDefs() { return registryData.relationshipDefs.getAll(); }
 
     public Collection<AtlasEntityDef> getAllEntityDefs() { return registryData.entityDefs.getAll(); }
     public AtlasEntityDef getEntityDefByGuid(String guid) {
@@ -211,6 +212,7 @@
         return registryData.relationshipDefs.getTypeDefByName(name);
     }
     public AtlasRelationshipType getRelationshipTypeByName(String name) { return registryData.relationshipDefs.getTypeByName(name); }
+
     public AtlasTransientTypeRegistry lockTypeRegistryForUpdate() throws AtlasBaseException {
         return lockTypeRegistryForUpdate(DEFAULT_LOCK_MAX_WAIT_TIME_IN_SECONDS);
     }
@@ -347,6 +349,7 @@
             addTypesWithNoRefResolve(parent.getAllStructDefs());
             addTypesWithNoRefResolve(parent.getAllClassificationDefs());
             addTypesWithNoRefResolve(parent.getAllEntityDefs());
+            addTypesWithNoRefResolve(parent.getAllRelationshipDefs());
 
             addedTypes.clear();
             updatedTypes.clear();
diff --git a/repository/src/main/java/org/apache/atlas/repository/graph/GraphHelper.java b/repository/src/main/java/org/apache/atlas/repository/graph/GraphHelper.java
index ca7fad0..329dd7a 100755
--- a/repository/src/main/java/org/apache/atlas/repository/graph/GraphHelper.java
+++ b/repository/src/main/java/org/apache/atlas/repository/graph/GraphHelper.java
@@ -24,7 +24,9 @@
 import org.apache.atlas.ApplicationProperties;
 import org.apache.atlas.AtlasException;
 import org.apache.atlas.RequestContext;
+import org.apache.atlas.exception.AtlasBaseException;
 import org.apache.atlas.model.instance.AtlasEntity.Status;
+import org.apache.atlas.model.instance.AtlasRelationship;
 import org.apache.atlas.repository.Constants;
 import org.apache.atlas.repository.RepositoryException;
 import org.apache.atlas.repository.graphdb.AtlasEdge;
@@ -259,31 +261,42 @@
      * Searches for a AtlasVertex with prop1=key1 && prop2=key2
      * @param args
      * @return AtlasVertex with the given property keys
-     * @throws EntityNotFoundException
+     * @throws AtlasBaseException
      */
     public AtlasVertex findVertex(Object... args) throws EntityNotFoundException {
+        return (AtlasVertex) findElement(true, args);
+    }
+
+    /**
+     * Args of the format prop1, key1, prop2, key2...
+     * Searches for a AtlasEdge with prop1=key1 && prop2=key2
+     * @param args
+     * @return AtlasEdge with the given property keys
+     * @throws AtlasBaseException
+     */
+    public AtlasEdge findEdge(Object... args) throws EntityNotFoundException {
+        return (AtlasEdge) findElement(false, args);
+    }
+
+    private AtlasElement findElement(boolean isVertexSearch, Object... args) throws EntityNotFoundException {
         AtlasGraphQuery query = graph.query();
-        for (int i = 0 ; i < args.length; i+=2) {
-            query = query.has((String) args[i], args[i+1]);
+
+        for (int i = 0; i < args.length; i += 2) {
+            query = query.has((String) args[i], args[i + 1]);
         }
 
-        Iterator<AtlasVertex> results = query.vertices().iterator();
-        // returning one since entityType, qualifiedName should be unique
-        AtlasVertex vertex = results.hasNext() ? results.next() : null;
+        Iterator<AtlasElement> results = isVertexSearch ? query.vertices().iterator() : query.edges().iterator();
+        AtlasElement           element = (results != null && results.hasNext()) ? results.next() : null;
 
-        if (vertex == null) {
-            String conditionStr = getConditionString(args);
-            if (LOG.isDebugEnabled()) {
-                LOG.debug("Could not find a vertex with {}", conditionStr);
-            }
-            throw new EntityNotFoundException("Could not find an entity in the repository with " + conditionStr);
-        } else {
-            if (LOG.isDebugEnabled()) {
-                LOG.debug("Found a vertex {} with {}", string(vertex), getConditionString(args));
-            }
+        if (element == null) {
+            throw new EntityNotFoundException("Could not find " + (isVertexSearch ? "vertex" : "edge") + " with condition: " + getConditionString(args));
         }
 
-        return vertex;
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("Found {} with condition {}", string(element), getConditionString(args));
+        }
+
+        return element;
     }
 
     //In some cases of parallel APIs, the edge is added, but get edge by label doesn't return the edge. ATLAS-1104
@@ -534,6 +547,9 @@
         return findVertex(Constants.GUID_PROPERTY_KEY, guid);
     }
 
+    public AtlasEdge getEdgeForGUID(String guid) throws EntityNotFoundException {
+        return findEdge(Constants.GUID_PROPERTY_KEY, guid);
+    }
 
     /**
      * Finds the Vertices that correspond to the given property values.  Property
@@ -646,12 +662,12 @@
         return getIdFromVertex(getTypeName(vertex), vertex);
     }
 
-    public static String getGuid(AtlasVertex vertex) {
-        return vertex.<String>getProperty(Constants.GUID_PROPERTY_KEY, String.class);
+    public static String getGuid(AtlasElement element) {
+        return element.<String>getProperty(Constants.GUID_PROPERTY_KEY, String.class);
     }
 
-    public static String getTypeName(AtlasVertex instanceVertex) {
-        return instanceVertex.getProperty(Constants.ENTITY_TYPE_PROPERTY_KEY, String.class);
+    public static String getTypeName(AtlasElement element) {
+        return element.getProperty(Constants.ENTITY_TYPE_PROPERTY_KEY, String.class);
     }
 
     public static Id.EntityState getState(AtlasElement element) {
@@ -663,8 +679,6 @@
         return element.getProperty(Constants.VERSION_PROPERTY_KEY, Integer.class);
     }
 
-
-
     public static String getStateAsString(AtlasElement element) {
         return element.getProperty(Constants.STATE_PROPERTY_KEY, String.class);
     }
@@ -673,6 +687,10 @@
         return (getState(element) == Id.EntityState.DELETED) ? Status.DELETED : Status.ACTIVE;
     }
 
+    public static AtlasRelationship.Status getEdgeStatus(AtlasElement element) {
+        return (getState(element) == Id.EntityState.DELETED) ? AtlasRelationship.Status.DELETED : AtlasRelationship.Status.ACTIVE;
+    }
+
     //Added conditions in fetching system attributes to handle test failures in GremlinTest where these properties are not set
     public static String getCreatedByAsString(AtlasElement element){
         return element.getProperty(Constants.CREATED_BY_KEY, String.class);
diff --git a/repository/src/main/java/org/apache/atlas/repository/store/graph/AtlasRelationshipStore.java b/repository/src/main/java/org/apache/atlas/repository/store/graph/AtlasRelationshipStore.java
new file mode 100644
index 0000000..341711a
--- /dev/null
+++ b/repository/src/main/java/org/apache/atlas/repository/store/graph/AtlasRelationshipStore.java
@@ -0,0 +1,53 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.repository.store.graph;
+
+import org.apache.atlas.exception.AtlasBaseException;
+import org.apache.atlas.model.instance.AtlasRelationship;
+
+/**
+ * Persistence/Retrieval API for AtlasRelationship
+ */
+public interface AtlasRelationshipStore {
+    /**
+     * Create a new relationship instance.
+     * @param relationship relationship instance definition
+     * @return AtlasRelationship d
+     */
+    AtlasRelationship create(AtlasRelationship relationship) throws AtlasBaseException;
+
+    /**
+     * Update an existing relationship instance.
+     * @param relationship relationship instance definition
+     * @return AtlasRelationship d
+     */
+    AtlasRelationship update(AtlasRelationship relationship) throws AtlasBaseException;
+
+    /**
+     * Retrieve a relationship instance using guid.
+     * @param guid relationship instance guid
+     * @return AtlasRelationship
+     */
+    AtlasRelationship getById(String guid) throws AtlasBaseException;
+
+    /**
+     * Delete a relationship instance using guid.
+     * @param guid relationship instance guid
+     */
+    void deleteById(String guid) throws AtlasBaseException;
+}
diff --git a/repository/src/main/java/org/apache/atlas/repository/store/graph/v1/AtlasGraphUtilsV1.java b/repository/src/main/java/org/apache/atlas/repository/store/graph/v1/AtlasGraphUtilsV1.java
index 560b338..00fe94b 100644
--- a/repository/src/main/java/org/apache/atlas/repository/store/graph/v1/AtlasGraphUtilsV1.java
+++ b/repository/src/main/java/org/apache/atlas/repository/store/graph/v1/AtlasGraphUtilsV1.java
@@ -35,6 +35,7 @@
 import org.apache.atlas.type.AtlasStructType.AtlasAttribute;
 import org.apache.atlas.type.AtlasType;
 import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -234,6 +235,18 @@
         return vertex;
     }
 
+    public static String getTypeNameFromGuid(String guid) {
+        String ret = null;
+
+        if (StringUtils.isNotEmpty(guid)) {
+            AtlasVertex vertex = AtlasGraphUtilsV1.findByGuid(guid);
+
+            ret = (vertex != null) ? AtlasGraphUtilsV1.getTypeName(vertex) : null;
+        }
+
+        return ret;
+    }
+
     public static boolean typeHasInstanceVertex(String typeName) throws AtlasBaseException {
         AtlasGraphQuery query = AtlasGraphProvider.getGraphInstance()
                 .query()
diff --git a/repository/src/main/java/org/apache/atlas/repository/store/graph/v1/AtlasRelationshipStoreV1.java b/repository/src/main/java/org/apache/atlas/repository/store/graph/v1/AtlasRelationshipStoreV1.java
new file mode 100644
index 0000000..8fe4888
--- /dev/null
+++ b/repository/src/main/java/org/apache/atlas/repository/store/graph/v1/AtlasRelationshipStoreV1.java
@@ -0,0 +1,365 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.repository.store.graph.v1;
+
+import org.apache.atlas.AtlasErrorCode;
+import org.apache.atlas.annotation.GraphTransaction;
+import org.apache.atlas.exception.AtlasBaseException;
+import org.apache.atlas.model.instance.AtlasObjectId;
+import org.apache.atlas.model.instance.AtlasRelationship;
+import org.apache.atlas.model.typedef.AtlasRelationshipDef;
+import org.apache.atlas.model.typedef.AtlasRelationshipEndDef;
+import org.apache.atlas.repository.Constants;
+import org.apache.atlas.repository.RepositoryException;
+import org.apache.atlas.repository.graph.GraphHelper;
+import org.apache.atlas.repository.graphdb.AtlasEdge;
+import org.apache.atlas.repository.graphdb.AtlasVertex;
+import org.apache.atlas.repository.store.graph.AtlasRelationshipDefStore;
+import org.apache.atlas.repository.store.graph.AtlasRelationshipStore;
+import org.apache.atlas.type.AtlasEntityType;
+import org.apache.atlas.type.AtlasRelationshipType;
+import org.apache.atlas.type.AtlasStructType;
+import org.apache.atlas.type.AtlasStructType.AtlasAttribute;
+import org.apache.atlas.type.AtlasType;
+import org.apache.atlas.type.AtlasTypeRegistry;
+import org.apache.atlas.type.AtlasTypeUtil;
+import org.apache.atlas.typesystem.exception.EntityNotFoundException;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+import javax.inject.Inject;
+import java.util.Date;
+import java.util.Map;
+import java.util.UUID;
+
+@Component
+public class AtlasRelationshipStoreV1 implements AtlasRelationshipStore {
+    private static final Logger LOG = LoggerFactory.getLogger(AtlasRelationshipStoreV1.class);
+
+    private final AtlasTypeRegistry    typeRegistry;
+    private final EntityGraphRetriever entityRetriever;
+    private final GraphHelper          graphHelper = GraphHelper.getInstance();
+
+    @Inject
+    public AtlasRelationshipStoreV1(AtlasTypeRegistry typeRegistry) {
+        this.typeRegistry    = typeRegistry;
+        this.entityRetriever = new EntityGraphRetriever(typeRegistry);
+    }
+
+    @Override
+    @GraphTransaction
+    public AtlasRelationship create(AtlasRelationship relationship) throws AtlasBaseException {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> create({})", relationship);
+        }
+
+        validateRelationship(relationship);
+
+        String      relationshipLabel = relationship.getRelationshipLabel();
+        AtlasVertex end1Vertex        = getVertexFromEndPoint(relationship.getEnd1());
+        AtlasVertex end2Vertex        = getVertexFromEndPoint(relationship.getEnd2());
+
+        AtlasRelationship ret;
+
+        // create relationship between two vertex
+        try {
+            AtlasEdge relationshipEdge = getRelationshipEdge(end1Vertex, end2Vertex, relationshipLabel);
+
+            if (relationshipEdge == null) {
+                relationshipEdge = createRelationEdge(end1Vertex, end2Vertex, relationship);
+
+                AtlasRelationshipType relationType = typeRegistry.getRelationshipTypeByName(relationship.getTypeName());
+
+                if (MapUtils.isNotEmpty(relationType.getAllAttributes())) {
+                    for (AtlasAttribute attr : relationType.getAllAttributes().values()) {
+                        String attrName  = attr.getName();
+                        Object attrValue = relationship.getAttribute(attrName);
+
+                        AtlasGraphUtilsV1.setProperty(relationshipEdge, attr.getVertexPropertyName(), attrValue);
+                    }
+                }
+
+                // create legacy edges if mentioned in relationDef
+                createLegacyEdges(relationType.getRelationshipDef(), end1Vertex, end2Vertex);
+
+                ret = mapEdgeToAtlasRelationship(relationshipEdge);
+
+            } else {
+                throw new AtlasBaseException(AtlasErrorCode.RELATIONSHIP_ALREADY_EXISTS, relationship.getTypeName(),
+                                             relationship.getEnd1().getGuid(), relationship.getEnd2().getGuid());
+            }
+        } catch (RepositoryException e) {
+            throw new AtlasBaseException(AtlasErrorCode.INTERNAL_ERROR, e);
+        }
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<== create({}): {}", relationship, ret);
+        }
+
+        return ret;
+    }
+
+    @Override
+    @GraphTransaction
+    public AtlasRelationship update(AtlasRelationship relationship) throws AtlasBaseException {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> update({})", relationship);
+        }
+
+        AtlasRelationship ret = null;
+
+        // TODO: update(relationship) implementation
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<== update({}): {}", relationship, ret);
+        }
+
+        return ret;
+    }
+
+    @Override
+    @GraphTransaction
+    public AtlasRelationship getById(String guid) throws AtlasBaseException {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> getById({})", guid);
+        }
+
+        AtlasRelationship ret;
+
+        try {
+            AtlasEdge edge = graphHelper.getEdgeForGUID(guid);
+
+            ret = mapEdgeToAtlasRelationship(edge);
+        } catch (EntityNotFoundException ex) {
+            throw new AtlasBaseException(AtlasErrorCode.RELATIONSHIP_GUID_NOT_FOUND, guid);
+        }
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<== getById({}): {}", guid, ret);
+        }
+
+        return ret;
+    }
+
+    @Override
+    @GraphTransaction
+    public void deleteById(String guid) throws AtlasBaseException {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> deleteById({})", guid);
+        }
+
+        // TODO: deleteById(guid) implementation
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<== deleteById({}): {}", guid);
+        }
+    }
+
+    private void validateRelationship(AtlasRelationship relationship) throws AtlasBaseException {
+        if (relationship == null) {
+            throw new AtlasBaseException(AtlasErrorCode.INVALID_PARAMETERS, "AtlasRelationship is null");
+        }
+
+        String                relationshipName = relationship.getTypeName();
+        AtlasRelationshipType relationshipType = typeRegistry.getRelationshipTypeByName(relationshipName);
+
+        if (relationshipType == null) {
+            throw new AtlasBaseException(AtlasErrorCode.INVALID_VALUE, "unknown relationship '" + relationshipName + "'");
+        }
+
+        AtlasObjectId end1 = relationship.getEnd1();
+
+        if (end1 == null) {
+            throw new AtlasBaseException(AtlasErrorCode.INVALID_PARAMETERS, "end1 is null");
+        }
+
+        String end1TypeName = end1.getTypeName();
+
+        if (StringUtils.isBlank(end1TypeName)) {
+            end1TypeName = AtlasGraphUtilsV1.getTypeNameFromGuid(end1.getGuid());
+        }
+
+        if (!relationshipType.getEnd1Type().isTypeOrSuperTypeOf(end1TypeName)) {
+            throw new AtlasBaseException(AtlasErrorCode.INVALID_RELATIONSHIP_END_TYPE, relationshipName,
+                                         relationshipType.getEnd1Type().getTypeName(), end1TypeName);
+        }
+
+        AtlasObjectId end2 = relationship.getEnd2();
+
+        if (end2 == null) {
+            throw new AtlasBaseException(AtlasErrorCode.INVALID_PARAMETERS, "end2 is null");
+        }
+
+        String end2TypeName = end2.getTypeName();
+
+        if (StringUtils.isBlank(end2TypeName)) {
+            end2TypeName = AtlasGraphUtilsV1.getTypeNameFromGuid(end2.getGuid());
+        }
+
+        if (!relationshipType.getEnd2Type().isTypeOrSuperTypeOf(end2TypeName)) {
+            throw new AtlasBaseException(AtlasErrorCode.INVALID_RELATIONSHIP_END_TYPE, relationshipName,
+                                         relationshipType.getEnd2Type().getTypeName(), end2TypeName);
+        }
+
+        validateEnd(end1);
+
+        validateEnd(end2);
+    }
+
+    private void validateEnd(AtlasObjectId end) throws AtlasBaseException {
+        String              guid             = end.getGuid();
+        String              typeName         = end.getTypeName();
+        Map<String, Object> uniqueAttributes = end.getUniqueAttributes();
+        AtlasVertex         endVertex        = AtlasGraphUtilsV1.findByGuid(guid);
+
+        if (!AtlasTypeUtil.isValidGuid(guid) || endVertex == null) {
+            throw new AtlasBaseException(AtlasErrorCode.INSTANCE_GUID_NOT_FOUND, guid);
+        } else if (MapUtils.isNotEmpty(uniqueAttributes))  {
+            AtlasEntityType entityType = typeRegistry.getEntityTypeByName(typeName);
+
+            if (AtlasGraphUtilsV1.findByUniqueAttributes(entityType, uniqueAttributes) == null) {
+                throw new AtlasBaseException(AtlasErrorCode.INSTANCE_BY_UNIQUE_ATTRIBUTE_NOT_FOUND, typeName, uniqueAttributes.toString());
+            }
+        }
+    }
+
+    private AtlasEdge getRelationshipEdge(AtlasVertex fromVertex, AtlasVertex toVertex, String relationshipLabel) {
+        AtlasEdge ret = graphHelper.getEdgeForLabel(fromVertex, relationshipLabel);
+
+        if (ret != null) {
+            AtlasVertex inVertex = ret.getInVertex();
+
+            if (inVertex != null) {
+                if (!StringUtils.equals(AtlasGraphUtilsV1.getIdFromVertex(inVertex),
+                                       AtlasGraphUtilsV1.getIdFromVertex(toVertex))) {
+                    ret = null;
+                }
+            }
+        }
+
+        return ret;
+    }
+
+    private int getRelationVersion(AtlasRelationship relationship) {
+        Long ret = relationship != null ? relationship.getVersion() : null;
+
+        return (ret != null) ? ret.intValue() : 0;
+    }
+
+    private AtlasVertex getVertexFromEndPoint(AtlasObjectId endPoint) {
+        AtlasVertex ret = null;
+
+        if (StringUtils.isNotEmpty(endPoint.getGuid())) {
+            ret = AtlasGraphUtilsV1.findByGuid(endPoint.getGuid());
+
+        } else if (StringUtils.isNotEmpty(endPoint.getTypeName()) && MapUtils.isNotEmpty(endPoint.getUniqueAttributes())) {
+            AtlasEntityType entityType = typeRegistry.getEntityTypeByName(endPoint.getTypeName());
+
+            ret = AtlasGraphUtilsV1.findByUniqueAttributes(entityType, endPoint.getUniqueAttributes());
+        }
+
+        return ret;
+    }
+
+    private void createLegacyEdges(AtlasRelationshipDef relationshipDef, AtlasVertex fromVertex, AtlasVertex toVertex) throws RepositoryException {
+        if (relationshipDef != null) {
+            AtlasRelationshipEndDef endDef1 = relationshipDef.getEndDef1();
+            AtlasRelationshipEndDef endDef2 = relationshipDef.getEndDef2();
+
+            if (endDef1 != null && endDef1.hasLegacyRelation()) {
+                graphHelper.getOrCreateEdge(fromVertex, toVertex, endDef1.getLegacyLabel());
+            }
+
+            if (endDef2 != null && endDef2.hasLegacyRelation()) {
+                graphHelper.getOrCreateEdge(toVertex, fromVertex, endDef2.getLegacyLabel());
+            }
+        }
+    }
+
+    private AtlasEdge createRelationEdge(AtlasVertex fromVertex, AtlasVertex toVertex, AtlasRelationship relationship) throws RepositoryException {
+        AtlasEdge ret = graphHelper.getOrCreateEdge(fromVertex, toVertex, relationship.getRelationshipLabel());
+
+        // add additional properties to edge
+        if (ret != null) {
+            final String guid = UUID.randomUUID().toString();
+
+            AtlasGraphUtilsV1.setProperty(ret, Constants.ENTITY_TYPE_PROPERTY_KEY, relationship.getTypeName());
+            AtlasGraphUtilsV1.setProperty(ret, Constants.GUID_PROPERTY_KEY, guid);
+            AtlasGraphUtilsV1.setProperty(ret, Constants.VERSION_PROPERTY_KEY, getRelationVersion(relationship));
+        }
+
+        return ret;
+    }
+
+    private AtlasRelationship mapEdgeToAtlasRelationship(AtlasEdge edge) throws AtlasBaseException {
+        AtlasRelationship ret = new AtlasRelationship();
+
+        mapSystemAttributes(edge, ret);
+
+        mapAttributes(edge, ret);
+
+        return ret;
+    }
+
+    private AtlasRelationship mapSystemAttributes(AtlasEdge edge, AtlasRelationship relationship) {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("Mapping system attributes for relationship");
+        }
+
+        relationship.setGuid(GraphHelper.getGuid(edge));
+        relationship.setTypeName(GraphHelper.getTypeName(edge));
+
+        relationship.setCreatedBy(GraphHelper.getCreatedByAsString(edge));
+        relationship.setUpdatedBy(GraphHelper.getModifiedByAsString(edge));
+
+        relationship.setCreateTime(new Date(GraphHelper.getCreatedTime(edge)));
+        relationship.setUpdateTime(new Date(GraphHelper.getModifiedTime(edge)));
+
+        relationship.setVersion(GraphHelper.getVersion(edge).longValue());
+        relationship.setStatus(GraphHelper.getEdgeStatus(edge));
+
+        AtlasVertex end1Vertex = edge.getOutVertex();
+        AtlasVertex end2Vertex = edge.getInVertex();
+
+        relationship.setEnd1(new AtlasObjectId(GraphHelper.getGuid(end1Vertex), GraphHelper.getTypeName(end1Vertex)));
+        relationship.setEnd2(new AtlasObjectId(GraphHelper.getGuid(end2Vertex), GraphHelper.getTypeName(end2Vertex)));
+
+        return relationship;
+    }
+
+    private void mapAttributes(AtlasEdge edge, AtlasRelationship relationship) throws AtlasBaseException {
+        AtlasType objType = typeRegistry.getType(relationship.getTypeName());
+
+        if (!(objType instanceof AtlasRelationshipType)) {
+            throw new AtlasBaseException(AtlasErrorCode.TYPE_NAME_INVALID, relationship.getTypeName());
+        }
+
+        AtlasRelationshipType relationshipType = (AtlasRelationshipType) objType;
+
+        for (AtlasAttribute attribute : relationshipType.getAllAttributes().values()) {
+            // mapping only primitive attributes
+            Object attrValue = entityRetriever.mapVertexToPrimitive(edge, attribute.getQualifiedName(),
+                                                                    attribute.getAttributeDef());
+
+            relationship.setAttribute(attribute.getName(), attrValue);
+        }
+    }
+}
\ No newline at end of file
diff --git a/repository/src/main/java/org/apache/atlas/repository/store/graph/v1/EntityGraphRetriever.java b/repository/src/main/java/org/apache/atlas/repository/store/graph/v1/EntityGraphRetriever.java
index 66f20da..9a8695a 100644
--- a/repository/src/main/java/org/apache/atlas/repository/store/graph/v1/EntityGraphRetriever.java
+++ b/repository/src/main/java/org/apache/atlas/repository/store/graph/v1/EntityGraphRetriever.java
@@ -34,6 +34,7 @@
 import org.apache.atlas.repository.graph.GraphHelper;
 import org.apache.atlas.repository.graphdb.AtlasEdge;
 import org.apache.atlas.repository.graphdb.AtlasEdgeDirection;
+import org.apache.atlas.repository.graphdb.AtlasElement;
 import org.apache.atlas.repository.graphdb.AtlasVertex;
 import org.apache.atlas.type.*;
 import org.apache.atlas.type.AtlasStructType.AtlasAttribute;
@@ -460,7 +461,7 @@
         return ret;
     }
 
-    private Object mapVertexToPrimitive(AtlasVertex entityVertex, final String vertexPropertyName, AtlasAttributeDef attrDef) {
+    public Object mapVertexToPrimitive(AtlasElement entityVertex, final String vertexPropertyName, AtlasAttributeDef attrDef) {
         Object ret = null;
 
         if (GraphHelper.getSingleValuedProperty(entityVertex, vertexPropertyName, Object.class) == null) {
diff --git a/repository/src/main/java/org/apache/atlas/repository/typestore/GraphBackedTypeStore.java b/repository/src/main/java/org/apache/atlas/repository/typestore/GraphBackedTypeStore.java
index 7a064b6..2dd339c 100644
--- a/repository/src/main/java/org/apache/atlas/repository/typestore/GraphBackedTypeStore.java
+++ b/repository/src/main/java/org/apache/atlas/repository/typestore/GraphBackedTypeStore.java
@@ -273,6 +273,10 @@
                 traits.add(new HierarchicalTypeDefinition(TraitType.class, typeName, typeDescription, superTypes, attributes));
                 break;
 
+            case RELATIONSHIP:
+                // v1 typesystem is not notified on new relation type
+                break;
+
             default:
                 throw new IllegalArgumentException("Unhandled type category " + typeCategory);
             }
diff --git a/repository/src/test/java/org/apache/atlas/TestModules.java b/repository/src/test/java/org/apache/atlas/TestModules.java
index 095af41..d28956d 100644
--- a/repository/src/test/java/org/apache/atlas/TestModules.java
+++ b/repository/src/test/java/org/apache/atlas/TestModules.java
@@ -47,9 +47,11 @@
 import org.apache.atlas.repository.impexp.ExportService;
 import org.apache.atlas.repository.store.graph.AtlasEntityDefStore;
 import org.apache.atlas.repository.store.graph.AtlasEntityStore;
+import org.apache.atlas.repository.store.graph.AtlasRelationshipStore;
 import org.apache.atlas.repository.store.graph.v1.AtlasEntityChangeNotifier;
 import org.apache.atlas.repository.store.graph.v1.AtlasEntityDefStoreV1;
 import org.apache.atlas.repository.store.graph.v1.AtlasEntityStoreV1;
+import org.apache.atlas.repository.store.graph.v1.AtlasRelationshipStoreV1;
 import org.apache.atlas.repository.store.graph.v1.AtlasTypeDefGraphStoreV1;
 import org.apache.atlas.repository.store.graph.v1.DeleteHandlerV1;
 import org.apache.atlas.repository.store.graph.v1.EntityGraphMapper;
@@ -152,6 +154,7 @@
             typeDefChangeListenerMultibinder.addBinding().to(GraphBackedSearchIndexer.class).asEagerSingleton();
 
             bind(AtlasEntityStore.class).to(AtlasEntityStoreV1.class);
+            bind(AtlasRelationshipStore.class).to(AtlasRelationshipStoreV1.class);
 
             // bind the MetadataService interface to an implementation
             bind(MetadataService.class).to(DefaultMetadataService.class).asEagerSingleton();
diff --git a/webapp/src/main/java/org/apache/atlas/web/rest/RelationshipREST.java b/webapp/src/main/java/org/apache/atlas/web/rest/RelationshipREST.java
new file mode 100644
index 0000000..144080a
--- /dev/null
+++ b/webapp/src/main/java/org/apache/atlas/web/rest/RelationshipREST.java
@@ -0,0 +1,137 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.atlas.web.rest;
+
+import org.apache.atlas.exception.AtlasBaseException;
+import org.apache.atlas.model.instance.AtlasRelationship;
+import org.apache.atlas.repository.store.graph.AtlasRelationshipStore;
+import org.apache.atlas.utils.AtlasPerfTracer;
+import org.apache.atlas.web.util.Servlets;
+import org.slf4j.Logger;
+import org.springframework.stereotype.Service;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+
+/**
+ * REST interface for entity relationships.
+ */
+@Path("v2/relation")
+@Singleton
+@Service
+public class RelationshipREST {
+    private static final Logger PERF_LOG = AtlasPerfTracer.getPerfLogger("rest.RelationshipREST");
+
+    private final AtlasRelationshipStore relationshipStore;
+
+    @Inject
+    public RelationshipREST(AtlasRelationshipStore relationshipStore) {
+        this.relationshipStore = relationshipStore;
+    }
+
+    /**
+     * Create a new relationship between entities.
+     */
+    @POST
+    @Consumes(Servlets.JSON_MEDIA_TYPE)
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasRelationship create(AtlasRelationship relationship) throws AtlasBaseException {
+        AtlasPerfTracer perf = null;
+
+        try {
+            if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
+                perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "RelationshipREST.create(" + relationship + ")");
+            }
+
+            return relationshipStore.create(relationship);
+        } finally {
+            AtlasPerfTracer.log(perf);
+        }
+    }
+
+    /**
+     * Update an existing relationship between entities.
+     */
+    @PUT
+    @Consumes(Servlets.JSON_MEDIA_TYPE)
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasRelationship update(AtlasRelationship relationship) throws AtlasBaseException {
+        AtlasPerfTracer perf = null;
+
+        try {
+            if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
+                perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "RelationshipREST.update(" + relationship + ")");
+            }
+
+            return relationshipStore.update(relationship);
+        } finally {
+            AtlasPerfTracer.log(perf);
+        }
+    }
+
+    /**
+     * Get relationship information between entities using guid.
+     */
+    @GET
+    @Path("/guid/{guid}")
+    @Consumes(Servlets.JSON_MEDIA_TYPE)
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasRelationship getById(@PathParam("guid") String guid) throws AtlasBaseException {
+        AtlasPerfTracer perf = null;
+
+        try {
+            if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
+                perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "RelationshipREST.getById(" + guid + ")");
+            }
+
+            return relationshipStore.getById(guid);
+        } finally {
+            AtlasPerfTracer.log(perf);
+        }
+    }
+
+    /**
+     * Delete a relationship between entities using guid.
+     */
+    @DELETE
+    @Path("/guid/{guid}")
+    @Consumes(Servlets.JSON_MEDIA_TYPE)
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public void deleteById(@PathParam("guid") String guid) throws AtlasBaseException {
+        AtlasPerfTracer perf = null;
+
+        try {
+            if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
+                perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "RelationshipREST.deleteById(" + guid + ")");
+            }
+
+            relationshipStore.deleteById(guid);
+        } finally {
+            AtlasPerfTracer.log(perf);
+        }
+    }
+}