Types

RawSearchResult

class neo4j_graphrag.types.RawSearchResult(*, records, metadata=None)

Represents the raw result returned from the retriever get_search_result method. It needs to be formatted further before being returned as a RetrieverResult.

Parameters:

• records (list[Record])

• metadata (dict[str, Any] | None)

records

A list of records from neo4j.

Type:

list[neo4j.Record]

metadata

Record-related metadata, such as score.

Type:

dict[str, Any] | None

RetrieverResult

class neo4j_graphrag.types.RetrieverResult(*, items, metadata=None)

Represents a result returned from a retriever.

Parameters:

• items (list[RetrieverResultItem])

• metadata (dict[str, Any] | None)

items

A list of retrieved items.

Type:

list[RetrieverResultItem]

metadata

Context-related metadata such as generated Cypher query in the Text2CypherRetriever.

Type:

dict[str, Any] | None

RetrieverResultItem

class neo4j_graphrag.types.RetrieverResultItem(*, content, metadata=None)

A single record returned from a retriever.

Parameters:

• content (Any)

• metadata (dict[str, Any] | None)

content

The context as will be provided to the LLM

Type:

str

metadata

Any metadata that can be included together with the text, related to that record (e.g. another node property)

Type:

Optional[dict]

LLMUsage

class neo4j_graphrag.llm.types.LLMUsage(*, request_tokens=None, response_tokens=None, total_tokens=None)

Token usage statistics returned by an LLM call.

Parameters:

• request_tokens (int | None)

• response_tokens (int | None)

• total_tokens (int | None)

request_tokens

Number of tokens in the prompt/request. None when not reported by the provider.

Type:

Optional[int]

response_tokens

Number of tokens in the completion/response. None when not reported by the provider.

Type:

Optional[int]

total_tokens

Total tokens consumed by the call. None when not reported by the provider.

Type:

Optional[int]

LLMResponse

class neo4j_graphrag.llm.types.LLMResponse(*, content, usage=None)

Response returned by an LLM invocation.

Parameters:

• content (str)

• usage (LLMUsage | None)

content

The text content of the LLM response.

Type:

str

usage

Token usage statistics for the call, if provided by the LLM.

Type:

Optional[LLMUsage]

LLMMessage

class neo4j_graphrag.types.LLMMessage

RagResultModel

class neo4j_graphrag.generation.types.RagResultModel(*, answer, retriever_result=None)

Parameters:

• answer (str)

• retriever_result (RetrieverResult | None)

DocumentInfo

class neo4j_graphrag.experimental.components.types.DocumentInfo(*, path, metadata=None, uid=<factory>, document_type=None)

A document loaded by a DataLoader.

Parameters:

• path (str)

• metadata (Dict[str, str] | None)

• uid (str)

• document_type (DocumentType | None)

path

Document path.

Type:

str

metadata

Metadata associated with this document.

Type:

Optional[dict[str, Any]]

uid

Unique identifier for this document.

Type:

str

document_type

Kind of document source, if known.

Type:

Optional[DocumentType]

LoadedDocument

class neo4j_graphrag.experimental.components.types.LoadedDocument(*, text, document_info)

Extracted text and metadata for a file loaded by a DataLoader.

Parameters:

• text (str)

• document_info (DocumentInfo)

TextChunk

class neo4j_graphrag.experimental.components.types.TextChunk(*, text, index, metadata=None, uid=<factory>)

A chunk of text split from a document by a text splitter.

Parameters:

• text (str)

• index (int)

• metadata (dict[str, Any] | None)

• uid (str)

text

The raw chunk text.

Type:

str

index

The position of this chunk in the original document.

Type:

int

metadata

Metadata associated with this chunk.

Type:

Optional[dict[str, Any]]

uid

Unique identifier for this chunk.

Type:

str

TextChunks

class neo4j_graphrag.experimental.components.types.TextChunks(*, chunks)

A collection of text chunks returned from a text splitter.

Parameters:

chunks (list[TextChunk])

chunks

A list of text chunks.

Type:

list[TextChunk]

Neo4jNode

class neo4j_graphrag.experimental.components.types.Neo4jNode(*, id, label, properties=<factory>, embedding_properties=<factory>)

Represents a Neo4j node.

Parameters:

• id (str)

• label (str)

• properties (dict[str, bool | int | float | str | date | time | datetime | List[bool | int | float | str] | GeoPoint])

• embedding_properties (dict[str, list[float]])

id

The ID of the node. This ID is used to refer to the node for relationship creation.

Type:

str

label

The label of the node.

Type:

str

properties

A dictionary of properties attached to the node.

Type:

dict[str, PropertyValue]

embedding_properties

A dictionary of embedding properties attached to the node.

Type:

dict[str, list[float]]

Neo4jRelationship

class neo4j_graphrag.experimental.components.types.Neo4jRelationship(*, start_node_id, end_node_id, type, properties=<factory>, embedding_properties=<factory>)

Represents a Neo4j relationship.

Parameters:

• start_node_id (str)

• end_node_id (str)

• type (str)

• properties (dict[str, bool | int | float | str | date | time | datetime | List[bool | int | float | str] | GeoPoint])

• embedding_properties (dict[str, list[float]])

start_node_id

The ID of the start node.

Type:

str

end_node_id

The ID of the end node.

Type:

str

type

The relationship type.

Type:

str

properties

A dictionary of properties attached to the relationship.

Type:

dict[str, PropertyValue]

embedding_properties

A dictionary of embedding properties attached to the relationship.

Type:

dict[str, list[float]]

Neo4jGraph

class neo4j_graphrag.experimental.components.types.Neo4jGraph(*, nodes=<factory>, relationships=<factory>)

Represents a Neo4j graph.

Parameters:

• nodes (list[Neo4jNode])

• relationships (list[Neo4jRelationship])

nodes

A list of nodes in the graph.

Type:

list[Neo4jNode]

relationships

A list of relationships in the graph.

Type:

list[Neo4jRelationship]

GeoPoint

class neo4j_graphrag.experimental.components.types.GeoPoint(*, latitude, longitude, height)

Represents a geographic point with latitude, longitude, and height.

Parameters:

• latitude (float)

• longitude (float)

• height (float)

latitude

The latitude coordinate.

Type:

float

longitude

The longitude coordinate.

Type:

float

height

The height/altitude coordinate.

Type:

float

KGWriterModel

class neo4j_graphrag.experimental.components.kg_writer.KGWriterModel(*, status, metadata=None)

Data model for the output of the Knowledge Graph writer.

Parameters:

• status (Literal['SUCCESS', 'FAILURE'])

• metadata (dict[str, Any] | None)

status

Whether the write operation was successful (“SUCCESS” or “FAILURE”).

Type:

Literal[‘SUCCESS’, ‘FAILURE’]

metadata

Optional dict. When status is SUCCESS, contains at least: - “statistics”: dict with node_count, relationship_count, nodes_per_label,

rel_per_type, input_files_count, input_files_total_size_bytes.

• “files”: list of file descriptors with file_path, etc. (ParquetWriter). Each file entry includes columns: a list of dicts with name, type, is_primary_key, and is_unique (KEY / synthetic __id__ / from/to vs UNIQUENESS constraints per GraphSchema). Node files include a constraints list with at least one single-property KEY (__id__ is injected when the schema has none). Relationship files include start_node_primary_keys / end_node_primary_keys as a one-element list: the first single-property schema KEY for that label, or __id__.

Type:

dict[str, Any] | None

PropertyType

class neo4j_graphrag.experimental.components.schema.PropertyType(*, name, type, description='', required=False)

Represents a property on a node or relationship in the graph.

Parameters:

• name (str)

• type (Literal['BOOLEAN', 'DATE', 'DURATION', 'FLOAT', 'INTEGER', 'LIST', 'LOCAL_DATETIME', 'LOCAL_TIME', 'POINT', 'STRING', 'ZONED_DATETIME', 'ZONED_TIME'])

• description (str)

• required (bool)

NodeType

class neo4j_graphrag.experimental.components.schema.NodeType(*, label, description='', properties=<factory>, additional_properties=<factory>)

Represents a possible node in the graph.

Parameters:

• label (str)

• description (str)

• properties (list[PropertyType])

• additional_properties (bool)

RelationshipType

class neo4j_graphrag.experimental.components.schema.RelationshipType(*, label, description='', properties=[], additional_properties=<factory>)

Represents a possible relationship between nodes in the graph.

Parameters:

• label (str)

• description (str)

• properties (list[PropertyType])

• additional_properties (bool)

Pattern

class neo4j_graphrag.experimental.components.schema.Pattern(*, source, relationship, target)

Represents a relationship pattern in the graph schema.

This model provides backward compatibility with tuple-based patterns through helper methods (__iter__, __getitem__, __eq__, __hash__).

Parameters:

• source (str)

• relationship (str)

• target (str)

GraphConstraintType

class neo4j_graphrag.experimental.components.schema.GraphConstraintType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Constraint kinds for ConstraintType.

UNIQUENESS is for node properties only in this API. Supports composite (multi-property) constraints. EXISTENCE marks a mandatory (non-null) node or relationship property (single property only — Neo4j does not support composite existence). KEY matches Neo4j NODE KEY / RELATIONSHIP KEY: mandatory and unique; supports composite (multi-property) constraints.

ConstraintType

class neo4j_graphrag.experimental.components.schema.ConstraintType(*, type, property_name='', property_names, node_type='', relationship_type=None)

Represents a schema-level constraint on a node or relationship property.

UNIQUENESS applies to node properties only. EXISTENCE and KEY use exactly one of node_type or relationship_type (non-empty), like Neo4j node vs relationship scope.

UNIQUENESS and KEY support composite (multi-property) constraints via property_names. EXISTENCE requires exactly one property (Neo4j does not support composite existence constraints).

Deprecated since version 0.x: property_name is deprecated in favour of property_names. It is kept for backward compatibility and is automatically migrated.

Parameters:

• type (GraphConstraintType)

• property_name (str)

• property_names (Tuple[str, ...])

• node_type (str)

• relationship_type (str | None)

GraphSchema

class neo4j_graphrag.experimental.components.schema.GraphSchema(*, node_types, relationship_types=(), patterns=(), constraints=(), additional_node_types=<factory>, additional_relationship_types=<factory>, additional_patterns=<factory>)

This model represents the expected node and relationship types in the graph.

It is used both for guiding the LLM in the entity and relation extraction component, and for cleaning the extracted graph in a post-processing step.

Warning

This model is immutable.

Parameters:

• node_types (Tuple[NodeType, ...])

• relationship_types (Tuple[RelationshipType, ...])

• patterns (Tuple[Pattern, ...])

• constraints (Tuple[ConstraintType, ...])

• additional_node_types (bool)

• additional_relationship_types (bool)

• additional_patterns (bool)

LexicalGraphConfig

class neo4j_graphrag.experimental.components.types.LexicalGraphConfig(*, id_prefix='', document_node_label='Document', chunk_node_label='Chunk', chunk_to_document_relationship_type='FROM_DOCUMENT', next_chunk_relationship_type='NEXT_CHUNK', node_to_chunk_relationship_type='FROM_CHUNK', chunk_id_property='id', chunk_index_property='index', chunk_text_property='text', chunk_embedding_property='embedding')

Configure all labels and property names in the lexical graph.

Parameters:

• id_prefix (str)

• document_node_label (str)

• chunk_node_label (str)

• chunk_to_document_relationship_type (str)

• next_chunk_relationship_type (str)

• node_to_chunk_relationship_type (str)

• chunk_id_property (str)

• chunk_index_property (str)

• chunk_text_property (str)

• chunk_embedding_property (str)

Neo4jDriverType

class neo4j_graphrag.experimental.pipeline.config.object_config.Neo4jDriverType(root=PydanticUndefined)

A model to wrap neo4j.Driver and Neo4jDriverConfig objects.

The parse method always returns a neo4j.Driver.

Parameters:

root (Driver | Neo4jDriverConfig)

Neo4jDriverConfig

class neo4j_graphrag.experimental.pipeline.config.object_config.Neo4jDriverConfig(*, class_=None, params_={})

Parameters:

• class_ (str | None)

• params_ (dict[str, float | str | ParamFromEnvConfig | ParamFromKeyConfig | dict[str, Any]])

LLMType

class neo4j_graphrag.experimental.pipeline.config.object_config.LLMType(root=PydanticUndefined)

A model to wrap LLMInterface and LLMConfig objects.

The parse method always returns an object inheriting from LLMInterface.

Parameters:

root (LLMInterface | LLMConfig)

LLMConfig

class neo4j_graphrag.experimental.pipeline.config.object_config.LLMConfig(*, class_=None, params_={})

Configuration for any LLMInterface object.

By default, will try to import from neo4j_graphrag.llm.

Parameters:

• class_ (str | None)

• params_ (dict[str, float | str | ParamFromEnvConfig | ParamFromKeyConfig | dict[str, Any]])

EmbedderType

class neo4j_graphrag.experimental.pipeline.config.object_config.EmbedderType(root=PydanticUndefined)

A model to wrap Embedder and EmbedderConfig objects.

The parse method always returns an object inheriting from Embedder.

Parameters:

root (Embedder | EmbedderConfig)

EmbedderConfig

class neo4j_graphrag.experimental.pipeline.config.object_config.EmbedderConfig(*, class_=None, params_={})

Configuration for any Embedder object.

By default, will try to import from neo4j_graphrag.embeddings.

Parameters:

• class_ (str | None)

• params_ (dict[str, float | str | ParamFromEnvConfig | ParamFromKeyConfig | dict[str, Any]])

ComponentType

class neo4j_graphrag.experimental.pipeline.config.object_config.ComponentType(root=PydanticUndefined)

Parameters:

root (Component | ComponentConfig)

ComponentConfig

class neo4j_graphrag.experimental.pipeline.config.object_config.ComponentConfig(*, class_=None, params_={}, run_params_={})

A config model for all components.

In addition to the object config, components can have pre-defined parameters that will be passed to the run method, ie run_params_.

Parameters:

• class_ (str | None)

• params_ (dict[str, float | str | ParamFromEnvConfig | ParamFromKeyConfig | dict[str, Any]])

• run_params_ (dict[str, float | str | ParamFromEnvConfig | ParamFromKeyConfig | dict[str, Any]])

ParamFromEnvConfig

class neo4j_graphrag.experimental.pipeline.config.param_resolver.ParamFromEnvConfig(*, resolver_=ParamResolverEnum.ENV, var_)

Parameters:

• resolver_ (Literal[ParamResolverEnum.ENV])

• var_ (str)

EventType

enum neo4j_graphrag.experimental.pipeline.notification.EventType(value)

Valid values are as follows:

PIPELINE_STARTED = <EventType.PIPELINE_STARTED: 'PIPELINE_STARTED'>

TASK_STARTED = <EventType.TASK_STARTED: 'TASK_STARTED'>

TASK_PROGRESS = <EventType.TASK_PROGRESS: 'TASK_PROGRESS'>

TASK_FINISHED = <EventType.TASK_FINISHED: 'TASK_FINISHED'>

PIPELINE_FINISHED = <EventType.PIPELINE_FINISHED: 'PIPELINE_FINISHED'>

PIPELINE_FAILED = <EventType.PIPELINE_FAILED: 'PIPELINE_FAILED'>

PipelineEvent

class neo4j_graphrag.experimental.pipeline.notification.PipelineEvent(*, event_type, run_id, timestamp=<factory>, message=None, payload=None)

Parameters:

• event_type (EventType)

• run_id (str)

• timestamp (datetime)

• message (str | None)

• payload (dict[str, Any] | None)

TaskEvent

class neo4j_graphrag.experimental.pipeline.notification.TaskEvent(*, event_type, run_id, timestamp=<factory>, message=None, payload=None, task_name)

Parameters:

• event_type (EventType)

• run_id (str)

• timestamp (datetime)

• message (str | None)

• payload (dict[str, Any] | None)

• task_name (str)

EventCallbackProtocol

class neo4j_graphrag.experimental.pipeline.notification.EventCallbackProtocol(*args, **kwargs)

This protocol is used to send events about pipeline progress from the pipeline itself. It will receive either PipelineEvent or TaskEvent depending on the event type.

__call__(event)

Call self as a function.

Parameters:

event (Event)

Return type:

Awaitable[None]

TaskProgressCallbackProtocol

class neo4j_graphrag.experimental.pipeline.types.context.TaskProgressNotifierProtocol(*args, **kwargs)

This protocol is used to send events from the component to the Pipeline callback protocol. The event sent to the callback will be of type TaskEvent, with event_type=TASK_PROGRESS.

__call__(message, data)

Call self as a function.

Parameters:

• message (str)

• data (dict[str, Any])

Return type:

Awaitable[None]

RunContext

class neo4j_graphrag.experimental.pipeline.types.context.RunContext(*, run_id, task_name, notifier=None)

Context passed to the component

Parameters:

• run_id (str)

• task_name (str)

• notifier (TaskProgressNotifierProtocol | None)