Overview

The Read and Enumeration endpoints provide comprehensive functionality for retrieving edge data from your graph. These endpoints allow you to:

Read individual edges by their unique identifier
Retrieve the first edge matching specific criteria
Read multiple edges by providing their GUIDs
Enumerate all edges in a graph
Search and filter edges based on labels, tags, and custom expressions
Implement pagination for large result sets
Include additional data and subordinate information in responses

Read Individual Edge

Retrieve a specific edge by its unique identifier using the GET: /v1.0/tenants/{tenant-guid}/graphs/{graph-guid}/edges/{edge-guid} endpoint.

To include additional information in the response, such as custom data fields and subordinate (child) edges, use the incldata and inclsub query parameters in your request.

incldata=true will include the Data property for each edge in the response.
inclsub=true will include subordinate (child) edges in the response.

curl --location 'http://localhost:8701/v1.0/tenants/00000000-0000-0000-0000-000000000000/graphs/00000000-0000-0000-0000-000000000000/edges/00000000-0000-0000-0000-000000000000' \
--header 'Authorization: ••••••'

import { LiteGraphSdk } from "litegraphdb";

var api = new LiteGraphSdk(
  "http://localhost:8701/",
  "<Tenant-Guid>",
  "*******"
);

const getEdgeById = async () => {
  try {
    const data = await api.Edge.read(guid, edgeGuid);
    console.log(data, "check data");
  } catch (err) {
    console.log("err:", JSON.stringify(err));
  }
};

import litegraph

sdk = litegraph.configure(
    endpoint="http://localhost:8701",
    tenant_guid="Tenant-Guid",
    graph_guid="Graph-Guid",
    access_key="******",
)

def retrieve_edge():
    edge = litegraph.Edge.retrieve(guid="edgeGuid")
    print(edge)

retrieve_edge()

using LiteGraph;
using LiteGraph.GraphRepositories.Sqlite;

LiteGraphClient liteGraph = new LiteGraphClient(new SqliteGraphRepository("litegraph.db"));
liteGraph.InitializeRepository();
Edge response = liteGraph.Edge.ReadByGuid(Guid.Parse("<tenant-guid>"), Guid.Parse("graph-guid"), Guid.Parse("edge-guid"));

Response

{
  "GUID": "00000000-0000-0000-0000-000000000000",
  "TenantGUID": "00000000-0000-0000-0000-000000000000",
  "GraphGUID": "00000000-0000-0000-0000-000000000000",
  "Name": "My test edge",
  "From": "00000000-0000-0000-0000-000000000000",
  "To": "00000000-0000-0000-0000-000000000001",
  "Cost": 10,
  "Labels": ["test"],
  "Tags": {
    "type": "edge",
    "test": "true"
  },
  "Data": {
    "Hello": "World"
  },
  "Vectors": [
    {
      "Model": "all-MiniLM-L6-v2",
      "Dimensionality": 384,
      "Content": "test",
      "Vectors": [0.1, 0.2, 0.3]
    }
  ],
  "CreatedUtc": "2024-12-27T18:12:38.653402Z",
  "LastUpdateUtc": "2024-12-27T18:12:38.653402Z"
}

Read First Edge

Retrieve the first edge that matches your specified criteria using GET: /v1.0/tenants/{tenant-id}/graphs/{graph-guid}/edges/first. This endpoint is useful when you need to get a single edge result based on ordering, labels, tags, or custom expressions. The request body allows you to specify filtering criteria and ordering preferences.

To include additional information in the response, such as custom data fields and subordinate (child) edges, use the incldata and inclsub query parameters in your request.

incldata=true will include the Data property for each edge in the response.
inclsub=true will include subordinate (child) edges in the response.

curl --location 'http://localhost:8701/v1.0/tenants/00000000-0000-0000-0000-000000000000/graphs/00000000-0000-0000-0000-000000000000/edges/first' \
--header 'content-type: application/json' \
--header 'Authorization: ••••••' \
--data '{
  "Ordering": "CreatedDescending",
  "Labels": [ ],
  "Tags": { },
  "Expr": { }
}'

import { LiteGraphSdk } from "litegraphdb";

var api = new LiteGraphSdk(
  "http://localhost:8701/",
  "<Tenant-Guid>",
  "*******"
);

const readFirstEdge = async () => {
  try {
    const data = await api.Edge.readFirst(guid, {});
    console.log(data, "check data");
  } catch (err) {
    console.log("err:", JSON.stringify(err), err);
  }
};

import litegraph

sdk = litegraph.configure(
    endpoint="http://localhost:8701",
    tenant_guid="Tenant-Guid",
    access_key="******",
)

def retrieve_first_edge():
    edge = litegraph.Edge.retrieve_first(ordering="CreatedDescending", graph_guid="Graph-Guid")
    print(edge)

retrieve_first_edge()

using LiteGraph;
using LiteGraph.GraphRepositories.Sqlite;

LiteGraphClient liteGraph = new LiteGraphClient(new SqliteGraphRepository("litegraph.db"));
liteGraph.InitializeRepository();
Edge response = liteGraph.Edge.ReadFirst(Guid.Parse("<tenant-guid>"), Guid.Parse("graph-guid"));

Read Multiple Edges by GUIDs

Retrieve multiple specific edges by providing their GUIDs as query parameters using GET: /v1.0/tenants/{tenant-guid}/graphs/{graph-guid}/edges?guids=<edge1-guid>,<edge2-guid>. This endpoint allows you to fetch several edges in a single request by specifying comma-separated GUIDs in the URL query string.

To include additional information in the response, such as custom data fields and subordinate (child) edges, use the incldata and inclsub query parameters in your request.

incldata=true will include the Data property for each edge in the response.
inclsub=true will include subordinate (child) edges in the response.

curl --location 'http://localhost:8701/v1.0/tenants/00000000-0000-0000-0000-000000000000/graphs/00000000-0000-0000-0000-000000000000/edges?guids=00000000-0000-0000-0000-000000000000,00000000-0000-0000-0000-000000000001' \
--header 'Authorization: ••••••'

import { LiteGraphSdk } from "litegraphdb";

var api = new LiteGraphSdk(
  "http://localhost:8701/",
  "<Tenant-Guid>",
  "*******"
);

const readManyEdges = async () => {
  try {
    const data = await api.Edge.readMany(guid, [edgeGuid]);
    console.log(data, "check data");
  } catch (err) {
    console.log("err:", JSON.stringify(err));
  }
};

import litegraph

sdk = litegraph.configure(
    endpoint="http://localhost:8701",
    tenant_guid="Tenant-Guid",
    access_key="******",
)

def retrieve_many_edge():
    edges = litegraph.Edge.retrieve_many(graph_guid="Graph-Guid", guids=["edgeGuid", "edgeGuid2"])
    print(edges)

retrieve_many_edge()

using LiteGraph;
using LiteGraph.GraphRepositories.Sqlite;

LiteGraphClient liteGraph = new LiteGraphClient(new SqliteGraphRepository("litegraph.db"));
liteGraph.InitializeRepository();
IEnumerable<Edge> response = liteGraph.Edge.ReadByGuids(Guid.Parse("<tenant-guid>"), new List<Guid>()
{
    Guid.Parse("edge-guid-1"),
    Guid.Parse("edge-guid-2")
});

Read All Edges

Retrieve all edges within your graph using GET: /v1.0/tenants/{tenant-guid}/graphs/{graph-guid}/edges. This endpoint returns a complete list of all edges associated with the specified graph.

To include additional information in the response, such as custom data fields and subordinate (child) edges, use the incldata and inclsub query parameters in your request.

incldata=true will include the Data property for each edge in the response.
inclsub=true will include subordinate (child) edges in the response.

curl --location 'http://localhost:8701/v1.0/tenants/00000000-0000-0000-0000-000000000000/graphs/00000000-0000-0000-0000-000000000000/edges' \
--header 'Authorization: ••••••'

import { LiteGraphSdk } from "litegraphdb";

var api = new LiteGraphSdk(
  "http://localhost:8701/",
  "<Tenant-Guid>",
  "*******"
);

const getEdgeList = async () => {
  try {
    const data = await api.Edge.readAll(guid);
    console.log(data, "check data");
  } catch (err) {
    console.log("err:", JSON.stringify(err), err);
  }
};

import litegraph

sdk = litegraph.configure(
    endpoint="http://localhost:8701",
    tenant_guid="Tenant-Guid",
    graph_guid="Graph-Guid",
    access_key="******",
)

def retrieve_all_edge():
    edges = litegraph.Edge.retrieve_all()
    print(edges)

retrieve_all_edge()

using LiteGraph;
using LiteGraph.GraphRepositories.Sqlite;

LiteGraphClient liteGraph = new LiteGraphClient(new SqliteGraphRepository("litegraph.db"));
liteGraph.InitializeRepository();
IEnumerable<Edge> response = liteGraph.Edge.ReadMany(Guid.Parse("<tenant-guid>"), Guid.Parse("<graph-guid>"));

Enumeration (GET)

The v2.0 enumeration endpoint GET: /v2.0/tenants/{tenant-guid}/graphs/{graph-guid}/edges provides enhanced enumeration capabilities with improved response formatting and additional metadata. This endpoint is designed for efficient enumeration of large edge collections with optimized response structures.

To include additional information in the response, such as custom data fields and subordinate (child) edges.

incldata=true will include the Data property for each edge in the response.
inclsub=true will include subordinate (child) edges in the response.
max-keys=<number> will limit the maximum number of edges returned in the response.
skip=<number> will skip the specified number of edges in the result set (useful for pagination).
continuationToken=<edgeGUID> will return results starting after the specified edge GUID (useful for pagination).

curl --location 'http://localhost:8701/v2.0/tenants/00000000-0000-0000-0000-000000000000/graphs/00000000-0000-0000-0000-000000000000/edges' \
--header 'Authorization: ••••••'

import { LiteGraphSdk } from "litegraphdb";

var api = new LiteGraphSdk(
  "http://localhost:8701/",
  "<Tenant-Guid>",
  "*******"
);

const enumerateEdges = async () => {
  try {
    const data = await api.Edge.enumerate(
      "00000000-0000-0000-0000-000000000000"
    );
    console.log(data, "check data");
  } catch (err) {
    console.log("err:", JSON.stringify(err));
  }
};

import litegraph

sdk = litegraph.configure(
    endpoint="http://localhost:8701",
    tenant_guid="Tenant-Guid",
    graph_guid="Graph-Guid",
    access_key="******",
)

def enumerate_edge():
    edges = litegraph.Edge.enumerate()
    print(edges)

enumerate_edge()

using LiteGraph;
using LiteGraph.GraphRepositories.Sqlite;

LiteGraphClient liteGraph = new LiteGraphClient(new SqliteGraphRepository("litegraph.db"));
liteGraph.InitializeRepository();
EnumerationResult<Edge> response = liteGraph.Edge.Enumerate();

Response

{
  "Success": true,
  "Timestamp": {
    "Start": "2025-09-09T10:03:54.787758Z",
    "End": "2025-09-09T10:03:54.805314Z",
    "TotalMs": 17.56,
    "Messages": {}
  },
  "MaxResults": 1000,
  "EndOfResults": true,
  "TotalRecords": 1,
  "RecordsRemaining": 0,
  "Objects": [
    {
      "TenantGUID": "00000000-0000-0000-0000-000000000000",
      "GUID": "a1d61bb1-f990-4b90-885c-a925a1cede9d",
      "GraphGUID": "d913a38a-20fc-4009-a0ec-56229f021885",
      "Name": "My test edge",
      "From": "eb787bc5-224b-4551-a70f-9a7eae07a0b8",
      "To": "b9ccf229-f36b-4f1f-98b1-a0e8a4373f71",
      "Cost": 10,
      "CreatedUtc": "2025-09-09T10:03:46.978477Z",
      "LastUpdateUtc": "2025-09-09T10:03:46.978477Z"
    }
  ]
}

Enumeration and Search (POST)

The advanced enumeration endpoint POST: /v2.0/tenants/{tenant-guid}/graphs/{graph-guid}/edges provides powerful search and filtering capabilities along with enumeration. This endpoint supports complex query parameters including ordering, pagination, label filtering, tag matching, and custom expressions. It's ideal for applications that need to implement sophisticated edge discovery and search functionality.

Search Parameters

The POST request body supports the following parameters:

Ordering: Sort results by creation date (CreatedAscending, CreatedDescending)
IncludeData: Whether to include custom data in the response
IncludeSubordinates: Whether to include subordinate edge information
MaxResults: Maximum number of results to return (for pagination)
Skip: Number of results to skip (for pagination)
ContinuationToken: Token for continuing pagination from a previous request
Labels: Array of labels to filter edges
Tags: Key-value pairs for tag-based filtering
Expr: Custom expression for advanced filtering

curl --location 'http://localhost:8701/v2.0/tenants/00000000-0000-0000-0000-000000000000/graphs/00000000-0000-0000-0000-000000000000/edges' \
--header 'Content-Type: application/json' \
--header 'Authorization: ••••••' \
--data '{
    "Ordering": "CreatedDescending",
    "IncludeData": false,
    "IncludeSubordinates": false,
    "MaxResults": 5,
    "Skip": 0,
    "ContinuationToken": null,
    "Labels": [ ],
    "Tags": { },
    "Expr": { }
}'

import { LiteGraphSdk } from "litegraphdb";

var api = new LiteGraphSdk(
  "http://localhost:8701/",
  "<Tenant-Guid>",
  "*******"
);

const enumerateAndSearchEdges = async () => {
  try {
    const data = await api.Edge.enumerateAndSearch(guid, {
      Ordering: "CreatedDescending",
      IncludeData: false,
      IncludeSubordinates: false,
      MaxResults: 5,
      ContinuationToken: null,
      Labels: [],
      Tags: {},
      Expr: {},
    });
    console.log(data, "check data");
  } catch (err) {
    console.log("err:", JSON.stringify(err));
  }
};

import litegraph

sdk = litegraph.configure(
    endpoint="http://localhost:8701",
    tenant_guid="Tenant-Guid",
    graph_guid="Graph-Guid",
    access_key="******",
)

def enumerate_with_query_edge():
    edges = litegraph.Edge.enumerate_with_query(
        expr=litegraph.ExprModel(
            Left="Name",
            Operator="Equals",
            Right="Test"
        )
    )
    print(edges)

enumerate_with_query_edge()

using LiteGraph;
using LiteGraph.GraphRepositories.Sqlite;

LiteGraphClient liteGraph = new LiteGraphClient(new SqliteGraphRepository("litegraph.db"));
liteGraph.InitializeRepository();
EnumerationResult<Edge> response = liteGraph.Edge.Enumerate(new EnumerationRequest()
{
    Ordering = EnumerationOrderEnum.CreatedDescending,
    IncludeData = true,
    IncludeSubordinates = true,
    MaxResults = 5,
    Skip = 0,
    ContinuationToken = null,
    Labels = new List<string>(),
    Tags = null,
    Expr = null
});

Response

{
  "Success": true,
  "Timestamp": {
    "Start": "2025-09-09T10:04:20.372731Z",
    "End": "2025-09-09T10:04:20.388938Z",
    "TotalMs": 16.21,
    "Messages": {}
  },
  "MaxResults": 5,
  "EndOfResults": true,
  "TotalRecords": 1,
  "RecordsRemaining": 0,
  "Objects": [
    {
      "TenantGUID": "00000000-0000-0000-0000-000000000000",
      "GUID": "a1d61bb1-f990-4b90-885c-a925a1cede9d",
      "GraphGUID": "d913a38a-20fc-4009-a0ec-56229f021885",
      "Name": "My test edge",
      "From": "eb787bc5-224b-4551-a70f-9a7eae07a0b8",
      "To": "b9ccf229-f36b-4f1f-98b1-a0e8a4373f71",
      "Cost": 10,
      "CreatedUtc": "2025-09-09T10:03:46.978477Z",
      "LastUpdateUtc": "2025-09-09T10:03:46.978477Z"
    }
  ]
}

Best Practices

When reading and enumerating edges, consider the following recommendations:

Use Query Parameters: Leverage incldata and inclsub parameters to control response size and performance
Implement Pagination: Use MaxResults, Skip, and ContinuationToken for large datasets
Optimize Queries: Use specific GUIDs when possible instead of reading all edges
Filter Results: Use labels, tags, and expressions to narrow down results
Cache Responses: Implement caching for frequently accessed edge data
Handle Large Results: Use enumeration endpoints for large edge collections
Validate Input: Always validate GUIDs and query parameters before making requests

Next Steps

After successfully reading and enumerating edges, you can:

Create nodes to establish graph structure and relationships
Perform graph traversal and path-finding operations
Implement vector search for semantic similarity queries
Update or delete specific edges based on query results
Build edge analytics and reporting features
Create edge visualization and exploration interfaces
Set up automated edge monitoring and validation
Implement edge-based business logic and workflows