@anvia/neo4j 1.0.2 → 1.0.4

package/README.md

@@ -2,23 +2,22 @@
 
 Schema-first local GraphRAG for Neo4j 2026.01 and newer.
 
+Provider-neutral schemas from `@anvia/graph` are accepted alongside the compatibility
+`defineNeo4jGraphSchema()` API. Registered graphs expose `graph.retrieve()`, and the shared
+`createGraphSearchTool()` factory gives Neo4j and Memgraph the same Agent tool API.
+
 ## Installation
 
 ```sh
-pnpm add @anvia/neo4j @anvia/core
+pnpm add @anvia/graph @anvia/neo4j @anvia/core
 ```
 
 ## Managed knowledge graph
 
 ```ts
 import { Agent } from "@anvia/core/agent";
-import { embedDocuments } from "@anvia/core/embeddings";
-import {
-  Neo4jClient,
-  createNeo4jGraphSearchTool,
-  defineNeo4jGraphSchema,
-  extractGraphFacts,
-} from "@anvia/neo4j";
+import { createGraphSearchTool, ingestGraphText } from "@anvia/graph";
+import { Neo4jClient, defineNeo4jGraphSchema } from "@anvia/neo4j";
 import { z } from "zod";
 
 const schema = defineNeo4jGraphSchema({
@@ -71,34 +70,23 @@ const graph = client.managedKnowledgeGraph({
 
 await graph.ensure({ indexTimeoutMs: 60_000 });
 
-const facts = await extractGraphFacts({ model: extractionModel, schema, chunks });
-const [embeddedChunks, embeddedEntities] = await Promise.all([
-  embedDocuments({
-    model: embeddingModel,
-    documents: chunks,
-    id: (chunk) => chunk.id,
-    content: (chunk) => chunk.text,
-  }),
-  embedDocuments({
-    model: embeddingModel,
-    documents: [...facts.output.entities],
-    id: (entity) => entity.key,
-    content: (entity) => formatEntity(entity),
-  }),
-]);
-
-const write = await graph.replaceDocuments({
-  documents,
-  chunks: embeddedChunks.documents,
-  entities: embeddedEntities.documents,
-  relationships: facts.output.relationships,
-  mentions: facts.output.mentions,
+const ingestion = await ingestGraphText({
+  graph,
+  document: { id: "incident-42", text },
+  extractionModel,
+  embeddingModel,
+  chunking: {
+    strategy: "recursive",
+    maxSize: 1_000,
+    overlap: 100,
+    separators: ["\n\n", "\n", " "],
+  },
   conflict: "error",
   orphanEntities: "delete",
 });
-console.log(write);
+console.log(ingestion.write);
 
-const searchGraph = createNeo4jGraphSearchTool({
+const searchGraph = createGraphSearchTool({
   name: "search_support_graph",
   description: "Search connected support incidents and products.",
   graph,
@@ -123,9 +111,10 @@ const searchGraph = createNeo4jGraphSearchTool({
 const agent = new Agent({ id: "support", model: chatModel, tools: [searchGraph] });
 ```
 
-The application owns file discovery, reading, chunking, entity embedding text, model loading,
-retry policy, and Agent lifecycle. `extractGraphFacts()` performs model extraction but no writes.
-`replaceDocuments()` performs one deterministic transaction but no model calls.
+The application owns file discovery, reading, model loading, retry policy, and Agent lifecycle.
+`ingestGraphText()` and `ingestGraphDocuments()` provide the convenient end-to-end path. Advanced
+callers can compose `prepareGraphDocuments()`, `extractGraphFacts()`, `embedDocuments()`, and
+`replaceDocuments()` directly when they need custom orchestration.
 
 Graph property schemas must use `z.strictObject()` and must not coerce, default, transform,
 preprocess, catch, trim, or otherwise overwrite values. This keeps extraction, comparison, and
@@ -181,6 +170,23 @@ const graph = client.knowledgeGraph({
 await graph.validate();
 ```
 
+## Graph explorer
+
+Managed and existing graph registrations implement the shared `GraphExplorer` contract:
+
+```ts
+const overview = await graph.explore({ mode: "overview", maxNodes: 100 });
+const neighborhood = await graph.explore({
+  mode: "expand",
+  nodeIds: [overview.nodes[0]!.id],
+  maxDepth: 1,
+});
+```
+
+The explorer returns Neo4j element IDs as opaque strings, limits every query, and omits embeddings
+and other `__anvia_*` properties. Use stable graph identity properties for application logic; use the
+opaque IDs only to expand the current view.
+
 Existing registrations are read-only and expose no provisioning or write methods. Use
 `client.nativeDriver()` for application-owned Cypher.
 

package/dist/chunk-PWE3ETSF.js

@@ -0,0 +1,176 @@
+import {
+  Neo4jKnowledgeGraphBase,
+  parseNeo4jProperties
+} from "./chunk-QNHOT7P2.js";
+
+// src/explore.ts
+import {
+  resolveGraphExploreOptions
+} from "@anvia/graph";
+import { int } from "neo4j-driver";
+async function exploreGraph(graph, options) {
+  if (!(graph instanceof Neo4jKnowledgeGraphBase)) {
+    throw new TypeError("exploreGraph requires a Neo4j knowledge graph registration.");
+  }
+  const resolved = resolveGraphExploreOptions(graph.schema, options);
+  const records = resolved.mode === "overview" ? await overviewNodes(graph, resolved) : await expandedNodes(graph, resolved);
+  const nodes = uniqueNodes(records.map((record) => nodeFromRecord(record, graph.schema)));
+  const visibleNodes = nodes.slice(0, resolved.maxNodes);
+  const relationships = await relationshipsBetween(
+    graph,
+    visibleNodes.map((node) => node.id),
+    resolved.relationships,
+    resolved.maxRelationships,
+    resolved.abortSignal
+  );
+  return {
+    nodes: visibleNodes,
+    relationships: relationships.slice(0, resolved.maxRelationships),
+    truncated: {
+      nodes: records.length > resolved.maxNodes || nodes.length > resolved.maxNodes,
+      relationships: relationships.length > resolved.maxRelationships
+    }
+  };
+}
+async function overviewNodes(graph, options) {
+  const result = await graph.query(
+    `MATCH (node)
+WHERE any(type IN labels(node) WHERE type IN $nodeTypes)
+RETURN elementId(node) AS id, labels(node) AS labels, properties(node) AS properties
+ORDER BY elementId(node)
+LIMIT $nodeLimit`,
+    { nodeTypes: options.nodeTypes, nodeLimit: int(options.maxNodes + 1) },
+    options.abortSignal
+  );
+  return result.records;
+}
+async function expandedNodes(graph, options) {
+  const roots = await graph.query(
+    `MATCH (node)
+WHERE elementId(node) IN $nodeIds
+  AND any(type IN labels(node) WHERE type IN $nodeTypes)
+RETURN elementId(node) AS id, labels(node) AS labels, properties(node) AS properties`,
+    { nodeIds: options.nodeIds, nodeTypes: options.nodeTypes },
+    options.abortSignal
+  );
+  if (options.relationships.length === 0) return roots.records;
+  const remainingNodeLimit = options.maxNodes + 1 - roots.records.length;
+  if (remainingNodeLimit <= 0) return roots.records;
+  const pattern = traversalPattern(options.direction, options.maxDepth);
+  const neighbors = await graph.query(
+    `MATCH (root) WHERE elementId(root) IN $nodeIds
+MATCH path = ${pattern}
+WHERE all(rel IN relationships(path) WHERE type(rel) IN $relationshipTypes)
+  AND any(type IN labels(node) WHERE type IN $nodeTypes)
+RETURN elementId(node) AS id, labels(node) AS labels, properties(node) AS properties
+LIMIT $nodeLimit`,
+    {
+      nodeIds: options.nodeIds,
+      nodeTypes: options.nodeTypes,
+      relationshipTypes: options.relationships,
+      nodeLimit: int(remainingNodeLimit)
+    },
+    options.abortSignal
+  );
+  return [...roots.records, ...neighbors.records];
+}
+async function relationshipsBetween(graph, nodeIds, relationshipTypes, maxRelationships, abortSignal) {
+  if (nodeIds.length === 0 || relationshipTypes.length === 0) return [];
+  const result = await graph.query(
+    `MATCH (from)-[relationship]->(to)
+WHERE elementId(from) IN $nodeIds
+  AND elementId(to) IN $nodeIds
+  AND type(relationship) IN $relationshipTypes
+RETURN elementId(relationship) AS id,
+       type(relationship) AS type,
+       elementId(from) AS source,
+       elementId(to) AS target,
+       properties(relationship) AS properties
+ORDER BY elementId(relationship)
+LIMIT $relationshipLimit`,
+    {
+      nodeIds,
+      relationshipTypes,
+      relationshipLimit: int(maxRelationships + 1)
+    },
+    abortSignal
+  );
+  return result.records.map(relationshipFromRecord);
+}
+function nodeFromRecord(record, schema) {
+  const id = stringValue(record.get("id"), "Neo4j explorer node id");
+  const labels = stringArray(record.get("labels"), "Neo4j explorer node labels");
+  const raw = objectValue(record.get("properties"), "Neo4j explorer node properties");
+  const type = labels.find((label) => label in schema.nodes);
+  if (type === void 0) throw new TypeError("Neo4j explorer node has no registered type.");
+  const properties = applicationProperties(raw, "Neo4j explorer node properties");
+  const node = {
+    id,
+    type,
+    identity: identityProperties(schema, type, properties),
+    properties
+  };
+  const key = raw.__anvia_key;
+  if (typeof key === "string") node.key = key;
+  return node;
+}
+function relationshipFromRecord(record) {
+  const raw = objectValue(record.get("properties"), "Neo4j explorer relationship properties");
+  const relationship = {
+    id: stringValue(record.get("id"), "Neo4j explorer relationship id"),
+    type: stringValue(record.get("type"), "Neo4j explorer relationship type"),
+    from: stringValue(record.get("source"), "Neo4j explorer relationship source"),
+    to: stringValue(record.get("target"), "Neo4j explorer relationship target"),
+    properties: applicationProperties(raw, "Neo4j explorer relationship properties")
+  };
+  const key = raw.__anvia_key;
+  if (typeof key === "string") relationship.key = key;
+  return relationship;
+}
+function identityProperties(schema, type, properties) {
+  const identity = {};
+  const definition = schema.nodes[type];
+  if (definition === void 0) return identity;
+  for (const property of definition.identity) {
+    const value = properties[property];
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      identity[property] = value;
+    }
+  }
+  return identity;
+}
+function applicationProperties(value, label) {
+  return parseNeo4jProperties(
+    Object.fromEntries(Object.entries(value).filter(([key]) => !key.startsWith("__anvia_"))),
+    label
+  );
+}
+function uniqueNodes(nodes) {
+  return [...new Map(nodes.map((node) => [node.id, node])).values()];
+}
+function traversalPattern(direction, maxDepth) {
+  if (direction === "outgoing") return `(root)-[*1..${maxDepth}]->(node)`;
+  if (direction === "incoming") return `(root)<-[*1..${maxDepth}]-(node)`;
+  return `(root)-[*1..${maxDepth}]-(node)`;
+}
+function stringValue(value, label) {
+  if (typeof value !== "string") throw new TypeError(`${label} must be a string.`);
+  return value;
+}
+function stringArray(value, label) {
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+    throw new TypeError(`${label} must be a string array.`);
+  }
+  return value;
+}
+function objectValue(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`${label} must be an object.`);
+  }
+  return value;
+}
+
+export {
+  exploreGraph
+};
+//# sourceMappingURL=chunk-PWE3ETSF.js.map

package/dist/chunk-PWE3ETSF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/explore.ts"],"sourcesContent":["import {\n  resolveGraphExploreOptions,\n  type GraphExploreNode,\n  type GraphExploreOptions,\n  type GraphExploreRelationship,\n  type GraphExploreResult,\n  type ResolvedGraphExploreExpandOptions,\n} from \"@anvia/graph\";\nimport { int, type Record as Neo4jRecord } from \"neo4j-driver\";\nimport { Neo4jKnowledgeGraphBase } from \"./graph.js\";\nimport { parseNeo4jProperties } from \"./schema.js\";\nimport type { Neo4jGraphSchema, Neo4jNodeIdentity } from \"./types.js\";\n\nexport async function exploreGraph<Schema extends Neo4jGraphSchema>(\n  graph: Neo4jKnowledgeGraphBase<Schema>,\n  options: GraphExploreOptions<Schema>,\n): Promise<GraphExploreResult> {\n  if (!(graph instanceof Neo4jKnowledgeGraphBase)) {\n    throw new TypeError(\"exploreGraph requires a Neo4j knowledge graph registration.\");\n  }\n  const resolved = resolveGraphExploreOptions(graph.schema, options);\n  const records =\n    resolved.mode === \"overview\"\n      ? await overviewNodes(graph, resolved)\n      : await expandedNodes(graph, resolved);\n  const nodes = uniqueNodes(records.map((record) => nodeFromRecord(record, graph.schema)));\n  const visibleNodes = nodes.slice(0, resolved.maxNodes);\n  const relationships = await relationshipsBetween(\n    graph,\n    visibleNodes.map((node) => node.id),\n    resolved.relationships,\n    resolved.maxRelationships,\n    resolved.abortSignal,\n  );\n  return {\n    nodes: visibleNodes,\n    relationships: relationships.slice(0, resolved.maxRelationships),\n    truncated: {\n      nodes: records.length > resolved.maxNodes || nodes.length > resolved.maxNodes,\n      relationships: relationships.length > resolved.maxRelationships,\n    },\n  };\n}\n\nasync function overviewNodes(\n  graph: Neo4jKnowledgeGraphBase,\n  options: ReturnType<typeof resolveGraphExploreOptions> & { mode: \"overview\" },\n): Promise<readonly Neo4jRecord[]> {\n  const result = await graph.query(\n    `MATCH (node)\nWHERE any(type IN labels(node) WHERE type IN $nodeTypes)\nRETURN elementId(node) AS id, labels(node) AS labels, properties(node) AS properties\nORDER BY elementId(node)\nLIMIT $nodeLimit`,\n    { nodeTypes: options.nodeTypes, nodeLimit: int(options.maxNodes + 1) },\n    options.abortSignal,\n  );\n  return result.records;\n}\n\nasync function expandedNodes(\n  graph: Neo4jKnowledgeGraphBase,\n  options: ResolvedGraphExploreExpandOptions,\n): Promise<readonly Neo4jRecord[]> {\n  const roots = await graph.query(\n    `MATCH (node)\nWHERE elementId(node) IN $nodeIds\n  AND any(type IN labels(node) WHERE type IN $nodeTypes)\nRETURN elementId(node) AS id, labels(node) AS labels, properties(node) AS properties`,\n    { nodeIds: options.nodeIds, nodeTypes: options.nodeTypes },\n    options.abortSignal,\n  );\n  if (options.relationships.length === 0) return roots.records;\n  const remainingNodeLimit = options.maxNodes + 1 - roots.records.length;\n  if (remainingNodeLimit <= 0) return roots.records;\n  const pattern = traversalPattern(options.direction, options.maxDepth);\n  const neighbors = await graph.query(\n    `MATCH (root) WHERE elementId(root) IN $nodeIds\nMATCH path = ${pattern}\nWHERE all(rel IN relationships(path) WHERE type(rel) IN $relationshipTypes)\n  AND any(type IN labels(node) WHERE type IN $nodeTypes)\nRETURN elementId(node) AS id, labels(node) AS labels, properties(node) AS properties\nLIMIT $nodeLimit`,\n    {\n      nodeIds: options.nodeIds,\n      nodeTypes: options.nodeTypes,\n      relationshipTypes: options.relationships,\n      nodeLimit: int(remainingNodeLimit),\n    },\n    options.abortSignal,\n  );\n  return [...roots.records, ...neighbors.records];\n}\n\nasync function relationshipsBetween(\n  graph: Neo4jKnowledgeGraphBase,\n  nodeIds: readonly string[],\n  relationshipTypes: readonly string[],\n  maxRelationships: number,\n  abortSignal?: AbortSignal,\n): Promise<GraphExploreRelationship[]> {\n  if (nodeIds.length === 0 || relationshipTypes.length === 0) return [];\n  const result = await graph.query(\n    `MATCH (from)-[relationship]->(to)\nWHERE elementId(from) IN $nodeIds\n  AND elementId(to) IN $nodeIds\n  AND type(relationship) IN $relationshipTypes\nRETURN elementId(relationship) AS id,\n       type(relationship) AS type,\n       elementId(from) AS source,\n       elementId(to) AS target,\n       properties(relationship) AS properties\nORDER BY elementId(relationship)\nLIMIT $relationshipLimit`,\n    {\n      nodeIds,\n      relationshipTypes,\n      relationshipLimit: int(maxRelationships + 1),\n    },\n    abortSignal,\n  );\n  return result.records.map(relationshipFromRecord);\n}\n\nfunction nodeFromRecord(record: Neo4jRecord, schema: Neo4jGraphSchema): GraphExploreNode {\n  const id = stringValue(record.get(\"id\"), \"Neo4j explorer node id\");\n  const labels = stringArray(record.get(\"labels\"), \"Neo4j explorer node labels\");\n  const raw = objectValue(record.get(\"properties\"), \"Neo4j explorer node properties\");\n  const type = labels.find((label) => label in schema.nodes);\n  if (type === undefined) throw new TypeError(\"Neo4j explorer node has no registered type.\");\n  const properties = applicationProperties(raw, \"Neo4j explorer node properties\");\n  const node: {\n    id: string;\n    key?: string | undefined;\n    type: string;\n    identity: Neo4jNodeIdentity;\n    properties: typeof properties;\n  } = {\n    id,\n    type,\n    identity: identityProperties(schema, type, properties),\n    properties,\n  };\n  const key = raw.__anvia_key;\n  if (typeof key === \"string\") node.key = key;\n  return node;\n}\n\nfunction relationshipFromRecord(record: Neo4jRecord): GraphExploreRelationship {\n  const raw = objectValue(record.get(\"properties\"), \"Neo4j explorer relationship properties\");\n  const relationship: {\n    id: string;\n    key?: string | undefined;\n    type: string;\n    from: string;\n    to: string;\n    properties: ReturnType<typeof applicationProperties>;\n  } = {\n    id: stringValue(record.get(\"id\"), \"Neo4j explorer relationship id\"),\n    type: stringValue(record.get(\"type\"), \"Neo4j explorer relationship type\"),\n    from: stringValue(record.get(\"source\"), \"Neo4j explorer relationship source\"),\n    to: stringValue(record.get(\"target\"), \"Neo4j explorer relationship target\"),\n    properties: applicationProperties(raw, \"Neo4j explorer relationship properties\"),\n  };\n  const key = raw.__anvia_key;\n  if (typeof key === \"string\") relationship.key = key;\n  return relationship;\n}\n\nfunction identityProperties(\n  schema: Neo4jGraphSchema,\n  type: string,\n  properties: ReturnType<typeof applicationProperties>,\n): Neo4jNodeIdentity {\n  const identity: Record<string, string | number | boolean> = {};\n  const definition = schema.nodes[type];\n  if (definition === undefined) return identity;\n  for (const property of definition.identity) {\n    const value = properties[property];\n    if (typeof value === \"string\" || typeof value === \"number\" || typeof value === \"boolean\") {\n      identity[property] = value;\n    }\n  }\n  return identity;\n}\n\nfunction applicationProperties(value: Record<string, unknown>, label: string) {\n  return parseNeo4jProperties(\n    Object.fromEntries(Object.entries(value).filter(([key]) => !key.startsWith(\"__anvia_\"))),\n    label,\n  );\n}\n\nfunction uniqueNodes(nodes: readonly GraphExploreNode[]): GraphExploreNode[] {\n  return [...new Map(nodes.map((node) => [node.id, node])).values()];\n}\n\nfunction traversalPattern(direction: \"outgoing\" | \"incoming\" | \"both\", maxDepth: number): string {\n  if (direction === \"outgoing\") return `(root)-[*1..${maxDepth}]->(node)`;\n  if (direction === \"incoming\") return `(root)<-[*1..${maxDepth}]-(node)`;\n  return `(root)-[*1..${maxDepth}]-(node)`;\n}\n\nfunction stringValue(value: unknown, label: string): string {\n  if (typeof value !== \"string\") throw new TypeError(`${label} must be a string.`);\n  return value;\n}\n\nfunction stringArray(value: unknown, label: string): string[] {\n  if (!Array.isArray(value) || !value.every((item) => typeof item === \"string\")) {\n    throw new TypeError(`${label} must be a string array.`);\n  }\n  return value;\n}\n\nfunction objectValue(value: unknown, label: string): Record<string, unknown> {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    throw new TypeError(`${label} must be an object.`);\n  }\n  return value as Record<string, unknown>;\n}\n"],"mappings":"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","names":[]}