@anvia/neo4j 1.0.0-rc.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Indra Zulfi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,212 @@
+# @anvia/neo4j
+
+Schema-first local GraphRAG for Neo4j 2026.01 and newer.
+
+## Installation
+
+```sh
+pnpm add @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 { z } from "zod";
+
+const schema = defineNeo4jGraphSchema({
+  nodes: {
+    Product: {
+      description: "A product or service.",
+      identity: ["id"],
+      properties: z.strictObject({ id: z.string(), name: z.string() }),
+    },
+    Incident: {
+      description: "An operational incident.",
+      identity: ["id"],
+      properties: z.strictObject({ id: z.string(), title: z.string() }),
+    },
+  },
+  relationships: {
+    AFFECTS: {
+      description: "An incident affects a product.",
+      from: "Incident",
+      to: "Product",
+      properties: z.strictObject({ severity: z.enum(["low", "high"]) }),
+    },
+  },
+});
+
+await using client = new Neo4jClient({
+  uri: process.env.NEO4J_URI!,
+  auth: {
+    username: process.env.NEO4J_USERNAME!,
+    password: process.env.NEO4J_PASSWORD!,
+  },
+});
+const graph = client.managedKnowledgeGraph({
+  name: "support",
+  schema,
+  resources: {
+    labels: { document: "SupportDocument", chunk: "SupportChunk", entity: "SupportEntity" },
+    indexes: {
+      chunks: {
+        vector: { name: "support_chunks_vector", dimensions: 1536, similarity: "cosine" },
+        fulltext: { name: "support_chunks_text" },
+      },
+      entities: {
+        vector: { name: "support_entities_vector", dimensions: 1536, similarity: "cosine" },
+        fulltext: { name: "support_entities_text", properties: ["id", "name", "title"] },
+      },
+    },
+  },
+});
+
+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,
+  conflict: "error",
+  orphanEntities: "delete",
+});
+console.log(write);
+
+const searchGraph = createNeo4jGraphSearchTool({
+  name: "search_support_graph",
+  description: "Search connected support incidents and products.",
+  graph,
+  model: embeddingModel,
+  search: {
+    type: "hybrid",
+    seeds: ["chunks", "entities"],
+    topK: 8,
+    candidatesPerSeed: 20,
+    rrfK: 60,
+  },
+  traversal: {
+    relationships: ["AFFECTS"],
+    direction: "both",
+    maxDepth: 2,
+    maxNodes: 40,
+    maxRelationships: 80,
+  },
+  evidence: { type: "chunks", maxChunks: 12 },
+});
+
+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.
+
+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
+stored Neo4j properties exact.
+
+Re-ingestion is document-scoped. `replaceDocuments()` removes the old chunks and their provenance
+before inserting the new representation. Facts supported by other documents remain. Use
+`deleteDocuments({ documentIds, orphanEntities })` for explicit removal.
+
+Both write operations return exact logical before-and-after counts for documents, chunks, entities,
+relationships, and mentions. A resource is `created`, `updated`, `deleted`, or `unchanged` by its
+stable public identity; the result is produced inside the same transaction as the mutation.
+
+Retrieval always requires an explicit evidence mode. `{ type: "none" }` performs no evidence read.
+Managed graphs can use `{ type: "chunks", maxChunks }` to hydrate exact source chunks in ranked
+provenance order. Seeds, nodes, and relationships refer to those records through `sourceChunkIds`.
+
+## Existing graph
+
+```ts
+const graph = client.knowledgeGraph({
+  schema,
+  seeds: {
+    incidents: {
+      nodeTypes: ["Incident"],
+      vectorIndex: {
+        name: "existing_incident_vectors",
+        property: "embedding",
+        dimensions: 1536,
+        similarity: "cosine",
+      },
+      fulltextIndex: {
+        name: "existing_incident_text",
+        properties: ["title"],
+      },
+    },
+    products: {
+      nodeTypes: ["Product"],
+      vectorIndex: {
+        name: "existing_product_vectors",
+        property: "embedding",
+        dimensions: 1536,
+        similarity: "cosine",
+      },
+      fulltextIndex: {
+        name: "existing_product_text",
+        properties: ["name"],
+      },
+    },
+  },
+});
+
+await graph.validate();
+```
+
+Existing registrations are read-only and expose no provisioning or write methods. Use
+`client.nativeDriver()` for application-owned Cypher.
+
+Existing graph registrations do not own Anvia document and chunk resources, so their retrieval and
+tool registrations accept only `evidence: { type: "none" }`.
+
+Each existing seed describes exactly one indexed node type and the complete expected vector and
+full-text index definitions. Register additional node types as separate seeds and fuse them with
+hybrid retrieval.
+
+Package operations use explicit transactions and do not invoke Neo4j's managed retry APIs. Abort
+signals roll back the active transaction. Applications decide whether and how to retry an entire
+operation.
+
+`Neo4jClient` supports `await using` and closes a driver that it creates from `uri` and `auth`.
+When a caller supplies `driver`, that driver remains caller-owned; closing or disposing the client
+only closes the Anvia client handle.
+
+The public property boundary is intentionally JSON-safe. Unsafe Neo4j integers, temporal and
+spatial objects, nodes, relationships, paths, maps, and heterogeneous property arrays are rejected
+instead of being coerced.
+
+## Development
+
+```sh
+pnpm --filter @anvia/neo4j typecheck
+pnpm --filter @anvia/neo4j test
+pnpm --filter @anvia/neo4j build
+```

package/dist/index.d.ts

@@ -0,0 +1,357 @@
+import { Driver, QueryResult, ManagedTransaction } from 'neo4j-driver';
+import * as _anvia_core_embeddings from '@anvia/core/embeddings';
+import { EmbeddedDocument } from '@anvia/core/embeddings';
+import * as _anvia_core from '@anvia/core';
+import { RetrySetting, CompletionModel, Usage } from '@anvia/core';
+import { Tool } from '@anvia/core/tool';
+import { z } from 'zod';
+
+type Neo4jPropertyPrimitive = string | number | boolean;
+type Neo4jPropertyValue = Neo4jPropertyPrimitive | readonly string[] | readonly number[] | readonly boolean[];
+type Neo4jProperties = Readonly<Record<string, Neo4jPropertyValue>>;
+type Neo4jNodeIdentity = Readonly<Record<string, Neo4jPropertyPrimitive>>;
+type Neo4jNodeDefinition = Readonly<{
+    description: string;
+    identity: readonly string[];
+    properties: z.ZodObject<z.ZodRawShape>;
+}>;
+type Neo4jRelationshipDefinition = Readonly<{
+    description: string;
+    from: string;
+    to: string;
+    identity?: readonly string[] | undefined;
+    properties: z.ZodObject<z.ZodRawShape>;
+}>;
+type Neo4jGraphSchemaOptions = Readonly<{
+    nodes: Readonly<Record<string, Neo4jNodeDefinition>>;
+    relationships: Readonly<Record<string, Neo4jRelationshipDefinition>>;
+}>;
+type Neo4jGraphSchema<Options extends Neo4jGraphSchemaOptions = Neo4jGraphSchemaOptions> = Readonly<Options & {
+    kind: "neo4j-graph-schema";
+}>;
+type NodeDefinitions<Schema extends Neo4jGraphSchema> = Schema["nodes"];
+type RelationshipDefinitions<Schema extends Neo4jGraphSchema> = Schema["relationships"];
+type Neo4jGraphEntity<Schema extends Neo4jGraphSchema = Neo4jGraphSchema> = {
+    [Type in keyof NodeDefinitions<Schema> & string]: Readonly<{
+        key: string;
+        type: Type;
+        identity: Neo4jNodeIdentity;
+        properties: z.output<NodeDefinitions<Schema>[Type]["properties"]> & Neo4jProperties;
+        sourceChunkIds: readonly string[];
+    }>;
+}[keyof NodeDefinitions<Schema> & string];
+type Neo4jGraphRelationship<Schema extends Neo4jGraphSchema = Neo4jGraphSchema> = {
+    [Type in keyof RelationshipDefinitions<Schema> & string]: Readonly<{
+        key: string;
+        type: Type;
+        from: string;
+        to: string;
+        properties: z.output<RelationshipDefinitions<Schema>[Type]["properties"]> & Neo4jProperties;
+        sourceChunkIds: readonly string[];
+    }>;
+}[keyof RelationshipDefinitions<Schema> & string];
+type Neo4jGraphMention = Readonly<{
+    chunkId: string;
+    entityKey: string;
+}>;
+type Neo4jGraphFacts<Schema extends Neo4jGraphSchema = Neo4jGraphSchema> = Readonly<{
+    entities: readonly Neo4jGraphEntity<Schema>[];
+    relationships: readonly Neo4jGraphRelationship<Schema>[];
+    mentions: readonly Neo4jGraphMention[];
+}>;
+type Neo4jGraphChunk<Metadata extends Neo4jProperties = Neo4jProperties> = Readonly<{
+    id: string;
+    documentId: string;
+    index: number;
+    text: string;
+    metadata?: Metadata | undefined;
+}>;
+type Neo4jGraphDocument<Properties extends Neo4jProperties = Neo4jProperties> = Readonly<{
+    id: string;
+    properties?: Properties | undefined;
+}>;
+type ExtractGraphFactsOptions<Schema extends Neo4jGraphSchema, Model extends CompletionModel> = Readonly<{
+    model: Model;
+    schema: Schema;
+    chunks: readonly Neo4jGraphChunk[];
+    instructions?: string | undefined;
+    retries?: RetrySetting | undefined;
+    concurrency?: number | undefined;
+    abortSignal?: AbortSignal | undefined;
+}>;
+type ExtractGraphFactsResult<Schema extends Neo4jGraphSchema> = Readonly<{
+    output: Neo4jGraphFacts<Schema>;
+    usage: Usage;
+}>;
+type Neo4jVectorIndex = Readonly<{
+    name: string;
+    dimensions: number;
+    similarity: "cosine" | "euclidean";
+}>;
+type Neo4jFulltextIndex = Readonly<{
+    name: string;
+    properties?: readonly string[] | undefined;
+}>;
+type ManagedNeo4jKnowledgeGraphOptions<Schema extends Neo4jGraphSchema> = Readonly<{
+    name: string;
+    schema: Schema;
+    resources: {
+        labels: {
+            document: string;
+            chunk: string;
+            entity: string;
+        };
+        indexes: {
+            chunks: {
+                vector: Neo4jVectorIndex;
+                fulltext?: Neo4jFulltextIndex | undefined;
+            };
+            entities: {
+                vector: Neo4jVectorIndex;
+                fulltext?: Neo4jFulltextIndex | undefined;
+            };
+        };
+    };
+}>;
+type ExistingNeo4jSeed = Readonly<{
+    nodeTypes: readonly string[];
+    vectorIndex: Neo4jVectorIndex & Readonly<{
+        property: string;
+    }>;
+    fulltextIndex?: (Neo4jFulltextIndex & Readonly<{
+        properties: readonly string[];
+    }>) | undefined;
+}>;
+type Neo4jKnowledgeGraphOptions<Schema extends Neo4jGraphSchema> = Readonly<{
+    schema: Schema;
+    seeds: Readonly<Record<string, ExistingNeo4jSeed>>;
+}>;
+type Neo4jClientOptions = Readonly<{
+    uri: string;
+    auth: {
+        username: string;
+        password: string;
+    };
+    database?: string | undefined;
+    driver?: never;
+}> | Readonly<{
+    driver: Driver;
+    database?: string | undefined;
+    uri?: never;
+    auth?: never;
+}>;
+type Neo4jGraphValidateOptions = Readonly<{
+    abortSignal?: AbortSignal | undefined;
+}>;
+type Neo4jGraphEnsureOptions = Readonly<{
+    indexTimeoutMs: number;
+    abortSignal?: AbortSignal | undefined;
+}>;
+type Neo4jGraphConflict = "error" | "overwrite" | "keep-existing";
+type Neo4jOrphanEntityPolicy = "delete" | "keep";
+type ReplaceNeo4jDocumentsOptions<Schema extends Neo4jGraphSchema> = Readonly<{
+    documents: readonly Neo4jGraphDocument[];
+    chunks: readonly EmbeddedDocument<Neo4jGraphChunk>[];
+    entities: readonly EmbeddedDocument<Neo4jGraphEntity<Schema>>[];
+    relationships: readonly Neo4jGraphRelationship<Schema>[];
+    mentions: readonly Neo4jGraphMention[];
+    conflict: Neo4jGraphConflict;
+    orphanEntities: Neo4jOrphanEntityPolicy;
+    abortSignal?: AbortSignal | undefined;
+}>;
+type DeleteNeo4jDocumentsOptions = Readonly<{
+    documentIds: readonly string[];
+    orphanEntities: Neo4jOrphanEntityPolicy;
+    abortSignal?: AbortSignal | undefined;
+}>;
+type Neo4jVectorSearchOptions = Readonly<{
+    type: "vector";
+    seeds: readonly string[];
+    topK: number;
+    minScore?: number | undefined;
+}>;
+type Neo4jHybridSearchOptions = Readonly<{
+    type: "hybrid";
+    seeds: readonly string[];
+    topK: number;
+    candidatesPerSeed: number;
+    rrfK: number;
+}>;
+type Neo4jGraphSearchOptions = Neo4jVectorSearchOptions | Neo4jHybridSearchOptions;
+type Neo4jGraphEvidenceOptions = Readonly<{
+    type: "none";
+}> | Readonly<{
+    type: "chunks";
+    maxChunks: number;
+}>;
+type Neo4jGraphEvidence = Readonly<{
+    chunkId: string;
+    documentId: string;
+    index: number;
+    text: string;
+    metadata: Neo4jProperties;
+}>;
+type Neo4jGraphTraversalOptions<Schema extends Neo4jGraphSchema = Neo4jGraphSchema> = Readonly<{
+    relationships: readonly (keyof Schema["relationships"] & string)[];
+    direction: "outgoing" | "incoming" | "both";
+    maxDepth: number;
+    maxNodes: number;
+    maxRelationships: number;
+}>;
+type Neo4jGraphContextSeed = Readonly<{
+    key: string;
+    type: string;
+    score: number;
+    properties: Neo4jProperties;
+    sourceChunkIds: readonly string[];
+}>;
+type Neo4jGraphContextNode = Readonly<{
+    key: string;
+    type: string;
+    identity: Neo4jNodeIdentity;
+    properties: Neo4jProperties;
+    sourceChunkIds: readonly string[];
+}>;
+type Neo4jGraphContextRelationship = Readonly<{
+    key: string;
+    type: string;
+    from: string;
+    to: string;
+    properties: Neo4jProperties;
+    sourceChunkIds: readonly string[];
+}>;
+type Neo4jGraphContext = Readonly<{
+    seeds: readonly Neo4jGraphContextSeed[];
+    nodes: readonly Neo4jGraphContextNode[];
+    relationships: readonly Neo4jGraphContextRelationship[];
+    evidence: readonly Neo4jGraphEvidence[];
+}>;
+type Neo4jGraphEvidenceCapability = "none" | "chunks";
+type AnyNeo4jKnowledgeGraph<Schema extends Neo4jGraphSchema> = Neo4jKnowledgeGraph<Schema> | ManagedNeo4jKnowledgeGraph<Schema>;
+type RetrieveGraphContextBase<Schema extends Neo4jGraphSchema> = Readonly<{
+    model: _anvia_core_embeddings.EmbeddingModel;
+    query: string;
+    search: Neo4jGraphSearchOptions;
+    traversal: Neo4jGraphTraversalOptions<Schema>;
+    retries?: RetrySetting | undefined;
+    abortSignal?: AbortSignal | undefined;
+}>;
+type RetrieveGraphContextOptions<Schema extends Neo4jGraphSchema> = (RetrieveGraphContextBase<Schema> & Readonly<{
+    graph: AnyNeo4jKnowledgeGraph<Schema>;
+    evidence: Readonly<{
+        type: "none";
+    }>;
+}>) | (RetrieveGraphContextBase<Schema> & Readonly<{
+    graph: ManagedNeo4jKnowledgeGraph<Schema>;
+    evidence: Readonly<{
+        type: "chunks";
+        maxChunks: number;
+    }>;
+}>);
+type CreateNeo4jGraphSearchToolBase<Schema extends Neo4jGraphSchema> = Readonly<{
+    name: string;
+    description: string;
+    model: _anvia_core_embeddings.EmbeddingModel;
+    search: Neo4jGraphSearchOptions;
+    traversal: Neo4jGraphTraversalOptions<Schema>;
+    retries?: RetrySetting | undefined;
+}>;
+type CreateNeo4jGraphSearchToolOptions<Schema extends Neo4jGraphSchema> = (CreateNeo4jGraphSearchToolBase<Schema> & Readonly<{
+    graph: AnyNeo4jKnowledgeGraph<Schema>;
+    evidence: Readonly<{
+        type: "none";
+    }>;
+}>) | (CreateNeo4jGraphSearchToolBase<Schema> & Readonly<{
+    graph: ManagedNeo4jKnowledgeGraph<Schema>;
+    evidence: Readonly<{
+        type: "chunks";
+        maxChunks: number;
+    }>;
+}>);
+type Neo4jGraphChangeCounts = Readonly<{
+    created: number;
+    updated: number;
+    deleted: number;
+    unchanged: number;
+}>;
+type Neo4jGraphWriteResult = Readonly<{
+    documents: Neo4jGraphChangeCounts;
+    chunks: Neo4jGraphChangeCounts;
+    entities: Neo4jGraphChangeCounts;
+    relationships: Neo4jGraphChangeCounts;
+    mentions: Neo4jGraphChangeCounts;
+}>;
+type Neo4jGraphSearchTool = Tool<{
+    query: string;
+}, Neo4jGraphContext>;
+
+type SeedRegistration = Readonly<{
+    labels: readonly string[];
+    vectorIndex: Neo4jVectorIndex & Readonly<{
+        property: string;
+    }>;
+    fulltextIndex?: (Neo4jFulltextIndex & Readonly<{
+        properties: readonly string[];
+    }>) | undefined;
+    entryRelationshipType?: string | undefined;
+}>;
+type GraphTransaction = Pick<ManagedTransaction, "run">;
+declare abstract class Neo4jKnowledgeGraphBase<Schema extends Neo4jGraphSchema = Neo4jGraphSchema, Evidence extends Neo4jGraphEvidenceCapability = Neo4jGraphEvidenceCapability> {
+    protected readonly owner: Neo4jClient;
+    readonly schema: Schema;
+    abstract readonly seeds: Readonly<Record<string, SeedRegistration>>;
+    abstract readonly evidenceCapability: Evidence;
+    protected constructor(owner: Neo4jClient, schema: Schema);
+    validate(options?: Neo4jGraphValidateOptions): Promise<void>;
+    query(text: string, parameters: Record<string, unknown>, abortSignal?: AbortSignal, access?: "read" | "write"): Promise<QueryResult>;
+    seed(name: string): SeedRegistration;
+    protected transaction<T>(abortSignal: AbortSignal | undefined, run: (transaction: GraphTransaction) => Promise<T>): Promise<T>;
+    private runTransaction;
+    private assertSupportedVersion;
+}
+declare class Neo4jKnowledgeGraph<Schema extends Neo4jGraphSchema> extends Neo4jKnowledgeGraphBase<Schema, "none"> {
+    readonly evidenceCapability: "none";
+    readonly seeds: Readonly<Record<string, SeedRegistration>>;
+    constructor(owner: Neo4jClient, options: Neo4jKnowledgeGraphOptions<Schema>);
+}
+declare class ManagedNeo4jKnowledgeGraph<Schema extends Neo4jGraphSchema> extends Neo4jKnowledgeGraphBase<Schema, "chunks"> {
+    readonly evidenceCapability: "chunks";
+    readonly seeds: Readonly<Record<string, SeedRegistration>>;
+    readonly resources: ManagedNeo4jKnowledgeGraphOptions<Schema>["resources"];
+    private readonly name;
+    constructor(owner: Neo4jClient, options: ManagedNeo4jKnowledgeGraphOptions<Schema>);
+    ensure(options: Neo4jGraphEnsureOptions): Promise<void>;
+    validate(options?: Neo4jGraphValidateOptions): Promise<void>;
+    replaceDocuments(options: ReplaceNeo4jDocumentsOptions<Schema>): Promise<Neo4jGraphWriteResult>;
+    deleteDocuments(options: DeleteNeo4jDocumentsOptions): Promise<Neo4jGraphWriteResult>;
+    private expectedConstraints;
+}
+
+declare class Neo4jClient {
+    private readonly driver;
+    private readonly ownsDriver;
+    private closed;
+    readonly database: string | undefined;
+    constructor(options: Neo4jClientOptions);
+    managedKnowledgeGraph<Schema extends Neo4jGraphSchema>(options: ManagedNeo4jKnowledgeGraphOptions<Schema>): ManagedNeo4jKnowledgeGraph<Schema>;
+    knowledgeGraph<Schema extends Neo4jGraphSchema>(options: Neo4jKnowledgeGraphOptions<Schema>): Neo4jKnowledgeGraph<Schema>;
+    nativeDriver(): Driver;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    private assertOpen;
+}
+
+declare function extractGraphFacts<Schema extends Neo4jGraphSchema, Model extends _anvia_core.CompletionModel>(options: ExtractGraphFactsOptions<Schema, Model>): Promise<ExtractGraphFactsResult<Schema>>;
+declare class GraphFactConflictError extends Error {
+    readonly factKey: string;
+    readonly sourceChunkIds: readonly string[];
+    constructor(factKey: string, sourceChunkIds: readonly string[]);
+}
+
+declare function retrieveGraphContext<Schema extends Neo4jGraphSchema>(options: RetrieveGraphContextOptions<Schema>): Promise<Neo4jGraphContext>;
+
+declare function defineNeo4jGraphSchema<const Options extends Neo4jGraphSchemaOptions>(options: Options): Neo4jGraphSchema<Options>;
+
+declare function createNeo4jGraphSearchTool<Schema extends Neo4jGraphSchema>(options: CreateNeo4jGraphSearchToolOptions<Schema>): Neo4jGraphSearchTool;
+
+export { type CreateNeo4jGraphSearchToolOptions, type DeleteNeo4jDocumentsOptions, type ExistingNeo4jSeed, type ExtractGraphFactsOptions, type ExtractGraphFactsResult, GraphFactConflictError, ManagedNeo4jKnowledgeGraph, type ManagedNeo4jKnowledgeGraphOptions, Neo4jClient, type Neo4jClientOptions, type Neo4jFulltextIndex, type Neo4jGraphChangeCounts, type Neo4jGraphChunk, type Neo4jGraphConflict, type Neo4jGraphContext, type Neo4jGraphContextNode, type Neo4jGraphContextRelationship, type Neo4jGraphContextSeed, type Neo4jGraphDocument, type Neo4jGraphEnsureOptions, type Neo4jGraphEntity, type Neo4jGraphEvidence, type Neo4jGraphEvidenceCapability, type Neo4jGraphEvidenceOptions, type Neo4jGraphFacts, type Neo4jGraphMention, type Neo4jGraphRelationship, type Neo4jGraphSchema, type Neo4jGraphSchemaOptions, type Neo4jGraphSearchOptions, type Neo4jGraphSearchTool, type Neo4jGraphTraversalOptions, type Neo4jGraphValidateOptions, type Neo4jGraphWriteResult, type Neo4jHybridSearchOptions, Neo4jKnowledgeGraph, type Neo4jKnowledgeGraphOptions, type Neo4jNodeDefinition, type Neo4jNodeIdentity, type Neo4jOrphanEntityPolicy, type Neo4jProperties, type Neo4jPropertyPrimitive, type Neo4jPropertyValue, type Neo4jRelationshipDefinition, type Neo4jVectorIndex, type Neo4jVectorSearchOptions, type ReplaceNeo4jDocumentsOptions, type RetrieveGraphContextOptions, createNeo4jGraphSearchTool, defineNeo4jGraphSchema, extractGraphFacts, retrieveGraphContext };