How can I get nodes and relationships to have properties in LLMGraphTransformer

[ali-habibzadeh]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

const llmGraphTransformerFiltered = new LLMGraphTransformer({
  llm: new ChatOpenAI({ temperature: 0, model: "gpt-4-turbo-preview", apiKey: appConfig.OPEN_AI_API_KEY }),
  allowedNodes: nodes,
  allowedRelationships: relationships,
  strictMode: false,
});
const text = await page.evaluate(() => {
  document.querySelectorAll("header, footer").forEach(el => el.remove());
  return `
      WEB_PAGE: ${document.location.href}
      TEXT:
      ${document.body.innerText}
      `;
});
const result_filtered = await llmGraphTransformerFiltered.convertToGraphDocuments([
  new Document({ pageContent: text }),
]);
await graph.addGraphDocuments(result_filtered);

Description

I am trying to generate a knowledge which is working well. However I see no doc or mention of how to add properties to nodes and relationships.

System Info

langchain: 0.2.9

[dosubot[bot]]

To get nodes and relationships to have properties in LLMGraphTransformer, you need to modify the schema definition in the createSchema function to include properties for nodes and relationships. Here is an example of how you can extend the schema to include properties:

function createSchema(allowedNodes: string[], allowedRelationships: string[]) {
  const dynamicGraphSchema = z.object({
    nodes: z
      .array(
        z.object({
          id: z.string(),
          type: createOptionalEnumType({
            enumValues: allowedNodes,
            description: "The type or label of the node.",
          }),
          properties: z.record(z.string(), z.any()).optional(), // Add properties field
        })
      )
      .describe("List of nodes"),
    relationships: z
      .array(
        z.object({
          sourceNodeId: z.string(),
          sourceNodeType: createOptionalEnumType({
            enumValues: allowedNodes,
            description: "The source node of the relationship.",
          }),
          relationshipType: createOptionalEnumType({
            enumValues: allowedRelationships,
            description: "The type of the relationship.",
            isRel: true,
          }),
          targetNodeId: z.string(),
          targetNodeType: createOptionalEnumType({
            enumValues: allowedNodes,
            description: "The target node of the relationship.",
          }),
          properties: z.record(z.string(), z.any()).optional(), // Add properties field
        })
      )
      .describe("List of relationships."),
  });

  return dynamicGraphSchema;
}

// eslint-disable-next-line @typescript-eslint/no-explicit-any
function mapToBaseNode(node: any): Node {
  return new Node({
    id: node.id,
    type: node.type ? toTitleCase(node.type) : "",
    properties: node.properties || {}, // Map properties
  });
}

// eslint-disable-next-line @typescript-eslint/no-explicit-any
function mapToBaseRelationship(relationship: any): Relationship {
  return new Relationship({
    source: new Node({
      id: relationship.sourceNodeId,
      type: relationship.sourceNodeType
        ? toTitleCase(relationship.sourceNodeType)
        : "",
    }),
    target: new Node({
      id: relationship.targetNodeId,
      type: relationship.targetNodeType
        ? toTitleCase(relationship.targetNodeType)
        : "",
    }),
    type: relationship.relationshipType.replace(" ", "_").toUpperCase(),
    properties: relationship.properties || {}, // Map properties
  });
}

By adding the properties field to both nodes and relationships in the schema and mapping functions, you can ensure that nodes and relationships can have properties in LLMGraphTransformer ^[1].

To continue talking to Dosu, mention @dosu.

[ali-habibzadeh]

This answer has no mention of which module is being used and how.
allowedRelationships and allowedNodes are string[] and don't seem to be able to become zod schemas.

[dosubot[bot]]

To modify the schema definition in the createSchema function to include properties for nodes and relationships using zod, you can follow this approach:

1. Node Properties:

   • Each node should have an id, a type, and optional properties.

2. Relationship Properties:

   • Each relationship should have sourceNodeId, sourceNodeType, relationshipType, targetNodeId, targetNodeType, and optional properties.

Here is a detailed example:

import { z } from "zod";

function createSchema(allowedNodes: string[], allowedRelationships: string[]) {
  // Define the schema for a node
  const nodeSchema = z.object({
    id: z.string(),
    type: z.enum(allowedNodes as [string, ...string[]]).describe("The type or label of the node."),
    properties: z.record(z.string(), z.any()).optional(), // Add properties field
  });

  // Define the schema for a relationship
  const relationshipSchema = z.object({
    sourceNodeId: z.string(),
    sourceNodeType: z.enum(allowedNodes as [string, ...string[]]).describe("The source node of the relationship."),
    relationshipType: z.enum(allowedRelationships as [string, ...string[]]).describe("The type of the relationship."),
    targetNodeId: z.string(),
    targetNodeType: z.enum(allowedNodes as [string, ...string[]]).describe("The target node of the relationship."),
    properties: z.record(z.string(), z.any()).optional(), // Add properties field
  });

  // Combine the node and relationship schemas into the main schema
  const dynamicGraphSchema = z.object({
    nodes: z.array(nodeSchema).describe("List of nodes"),
    relationships: z.array(relationshipSchema).describe("List of relationships."),
  });

  return dynamicGraphSchema;
}

// eslint-disable-next-line @typescript-eslint/no-explicit-any
function mapToBaseNode(node: any): Node {
  return new Node({
    id: node.id,
    type: node.type ? toTitleCase(node.type) : "",
    properties: node.properties || {}, // Map properties
  });
}

// eslint-disable-next-line @typescript-eslint/no-explicit-any
function mapToBaseRelationship(relationship: any): Relationship {
  return new Relationship({
    source: new Node({
      id: relationship.sourceNodeId,
      type: relationship.sourceNodeType ? toTitleCase(relationship.sourceNodeType) : "",
    }),
    target: new Node({
      id: relationship.targetNodeId,
      type: relationship.targetNodeType ? toTitleCase(relationship.targetNodeType) : "",
    }),
    type: relationship.relationshipType.replace(" ", "_").toUpperCase(),
    properties: relationship.properties || {}, // Map properties
  });
}

This code ensures that the schema is well-defined and that the properties for nodes and relationships are included as required. The allowedNodes and allowedRelationships arrays are used to create zod enums, ensuring that the types are restricted to the allowed values ^[1].

To continue talking to Dosu, mention @dosu.