Knowledge Graph

Memory Advanced

The knowledge graph is a network of memory objects connected by typed edges. It enables relationship-based queries, allowing agents to discover contextually relevant information by traversing connections between objects rather than relying solely on keyword or semantic search.

Core concepts

Nodes

Nodes are memory objects — the same objects you create via schemas and manage in the Explorer. Every memory object is automatically a node in the knowledge graph.

Edges

Edges are typed, directional connections between two objects. An edge expresses a semantic relationship such as “references”, “belongs to”, or “resolves”. Each edge has a source object, a target object, and an edge type.

Edge Types

Edge types are named categories of relationships. They define the vocabulary of connections available in your graph (e.g., References, BelongsTo, RelatesTo, Resolves). Edge types are shared across your organization.

Creating edges

To connect two objects with a typed relationship:

1. Identify the source object (the “from” side of the relationship) and the target object (the “to” side).

2. Choose an edge type that describes the relationship. Use existing edge types when possible to maintain consistency across your graph.

3. Create the edge. The connection is immediately available for graph traversal and neighborhood queries.

Tip

Think carefully about edge direction. “TroubleshootingGuide resolves Symptom” reads naturally as a directional relationship. Consistent edge direction makes the graph easier to query and understand.

Edge types

Edge types define the vocabulary of relationships in your knowledge graph. They are organization-scoped, meaning each organization maintains its own set of edge types that define the kinds of relationships available across all knowledge graph nodes.

Common edge types include:

Edge type	Description	Example
References	One object references or cites another	A document references a product spec
BelongsTo	An object is part of or owned by another	A FAQ entry belongs to a category
RelatesTo	A general association between objects	Two troubleshooting guides cover related topics
Resolves	One object provides a resolution for another	A fix resolves a known issue
DependsOn	One object requires another	A procedure depends on a prerequisite step
Contains	One object contains or includes another	A product bundle contains individual products
Causes	One object causes or triggers another	An error condition causes a specific symptom

You can create custom edge types tailored to your domain (e.g., Escalates, Supersedes, Implements) to model the specific relationships that matter for your organization. Edge types can be created and managed from the admin panel.

The platform also creates default edge types for common relationships between mirrored platform objects (agents, tools, operating protocols, etc.).

Listing neighbors

From any object, you can list its neighbors — objects directly connected by one or more edges. Neighbor queries support:

• Direction filtering — show only outgoing edges (this object points to others), incoming edges (others point to this object), or both.
• Edge type filtering — show only neighbors connected by specific edge types (e.g., only References edges).
• Pagination — handle objects with many connections efficiently.

This is useful for understanding an object’s context: what does it reference, what references it, and what other objects are in its neighborhood.

Neighborhood RAG

Neighborhood RAG (Retrieval-Augmented Generation) is the most powerful way agents use the knowledge graph. It combines graph traversal with semantic search to find contextually relevant information.

How it works:

1. Start from a known root object. The agent identifies a relevant starting point — for example, a product the user is asking about.

2. Traverse the graph. The system walks outgoing edges from the root object, collecting all objects in the neighborhood (direct and transitive connections).

3. Rank by semantic relevance. The collected neighborhood objects are ranked by semantic similarity to the agent’s current query.

4. Return the most relevant results. The top-ranked objects from the neighborhood are returned to the agent as context for generating a response.

Note

Neighborhood RAG is more precise than global semantic search because it restricts the search space to objects that are structurally related to the starting point. This reduces noise and surfaces genuinely relevant context.

How agents use the graph

Agents interact with the knowledge graph primarily through the neighborhoodRag tool:

1. During a conversation, the agent identifies a known memory object relevant to the user’s question (e.g., a specific product, a ticket, or a device).
2. The agent calls neighborhoodRag with the root object’s ID and the user’s query.
3. The system traverses the graph from that root, collects neighborhood objects, and ranks them by semantic relevance.
4. The agent receives the most relevant related objects and uses them to generate an informed response.

This enables agents to answer questions like “What troubleshooting steps are available for the LaserJet 500?” by starting from the LaserJet 500 product object, traversing its edges, and finding linked troubleshooting guides.

Deleting edges

Edges support soft deletion. When you delete an edge:

• The connection is marked as deleted and no longer appears in neighbor queries by default
• The edge record is preserved for audit purposes
• You can restore a soft-deleted edge if needed

To permanently filter out deleted edges, neighbor queries exclude them by default. Pass includeDeleted: true to see deleted edges alongside active ones.

Querying the graph

The knowledge graph supports multiple query strategies that can be combined:

Strategy	Description	Best for
Semantic search	Find objects by meaning using natural language queries	Fuzzy, intent-based questions
Type filtering	Restrict results to specific schema types	”Show me all FAQEntry objects”
Graph traversal	Walk edges from a starting object	”What is related to this product?”
Combined	Semantic search within a graph neighborhood	”What troubleshooting steps relate to this device?”

Tip

The strongest retrieval path is typically a structured scope (type filter + graph neighborhood) followed by semantic ranking within that scope. This gives you precision from structure and relevance from semantics.

Use cases

Linking troubleshooting steps to symptoms

Create Symptom objects (e.g., “VPN connection drops after 5 minutes”) and TroubleshootingGuide objects (e.g., “VPN Keepalive Configuration”). Connect them with Resolves edges. When a user describes a symptom, the agent finds the matching symptom object and traverses edges to discover resolution guides.

Connecting products to documentation

Link Product objects to their related Manual, FAQEntry, and KnownIssue objects using References edges. Agents can start from a product and walk the graph to find all associated documentation.

Relating tickets to known issues

When a support ticket matches a known issue, connect them with a RelatesTo edge. Future agents handling similar tickets can discover the known issue and its resolution through the graph.

Next steps

Objects Create and manage the memory objects that form nodes in the graph.

Schemas Define data types that structure your knowledge graph nodes.

Explorer Browse objects and their relationships in a visual interface.