@langchain/neo4j 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) LangChain, Inc.
+
+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,281 @@
+# @langchain/neo4j
+
+This package contains the [LangChain.js](https://github.com/langchain-ai/langchainjs) integrations for [Neo4j](https://neo4j.com/) graph database, including support for [Memgraph](https://memgraph.com/) (which uses the Bolt protocol).
+
+## Installation
+
+```bash
+npm install @langchain/neo4j @langchain/core
+```
+
+You also need to have `neo4j-driver` installed (it is included as a dependency of this package).
+
+## Components
+
+### Neo4jGraph
+
+A wrapper around the Neo4j database that provides schema introspection and query execution.
+
+```typescript
+import { Neo4jGraph } from "@langchain/neo4j";
+
+const graph = await Neo4jGraph.initialize({
+  url: "bolt://localhost:7687",
+  username: "neo4j",
+  password: "password",
+  database: "neo4j", // optional, defaults to "neo4j"
+});
+
+// Get the database schema
+console.log(graph.getSchema());
+
+// Run a Cypher query
+const results = await graph.query("MATCH (n:Person) RETURN n.name LIMIT 10");
+
+// Clean up
+await graph.close();
+```
+
+#### Enhanced Schema
+
+You can enable enhanced schema introspection to get more detailed information about node and relationship properties, including value distributions, min/max ranges, and distinct counts:
+
+```typescript
+const graph = await Neo4jGraph.initialize({
+  url: "bolt://localhost:7687",
+  username: "neo4j",
+  password: "password",
+  enhancedSchema: true,
+});
+```
+
+#### Graph Documents
+
+You can add structured graph documents (nodes and relationships extracted from text) to the database:
+
+```typescript
+import { Neo4jGraph, Node, Relationship, GraphDocument } from "@langchain/neo4j";
+import { Document } from "@langchain/core/documents";
+
+const source = new Document({
+  pageContent: "Alice works at Acme Corp.",
+  metadata: { id: "doc1" },
+});
+
+const alice = new Node({ id: "alice", type: "Person", properties: { name: "Alice" } });
+const acme = new Node({ id: "acme", type: "Company", properties: { name: "Acme Corp" } });
+const worksAt = new Relationship({
+  source: alice,
+  target: acme,
+  type: "WORKS_AT",
+});
+
+const graphDoc = new GraphDocument({
+  nodes: [alice, acme],
+  relationships: [worksAt],
+  source,
+});
+
+await graph.addGraphDocuments([graphDoc]);
+```
+
+### Neo4jVectorStore
+
+A vector store implementation backed by Neo4j's vector index capabilities. Supports vector search, hybrid search (vector + full-text), and metadata filtering.
+
+```typescript
+import { Neo4jVectorStore } from "@langchain/neo4j";
+import { OpenAIEmbeddings } from "@langchain/openai";
+
+const embeddings = new OpenAIEmbeddings();
+
+// Create from documents
+const vectorStore = await Neo4jVectorStore.fromDocuments(docs, embeddings, {
+  url: "bolt://localhost:7687",
+  username: "neo4j",
+  password: "password",
+  indexName: "vector",
+  nodeLabel: "Chunk",
+  textNodeProperty: "text",
+  embeddingNodeProperty: "embedding",
+});
+
+// Similarity search
+const results = await vectorStore.similaritySearch("What is Neo4j?", 4);
+
+// Similarity search with score
+const resultsWithScore = await vectorStore.similaritySearchWithScore(
+  "What is Neo4j?",
+  4
+);
+
+// Clean up
+await vectorStore.close();
+```
+
+#### Hybrid Search
+
+Combine vector search with full-text search for improved retrieval:
+
+```typescript
+const vectorStore = await Neo4jVectorStore.fromDocuments(docs, embeddings, {
+  url: "bolt://localhost:7687",
+  username: "neo4j",
+  password: "password",
+  searchType: "hybrid",
+  indexName: "vector",
+  keywordIndexName: "keyword",
+  nodeLabel: "Chunk",
+});
+```
+
+#### Using an Existing Index
+
+Connect to a pre-existing vector index:
+
+```typescript
+const vectorStore = await Neo4jVectorStore.fromExistingIndex(embeddings, {
+  url: "bolt://localhost:7687",
+  username: "neo4j",
+  password: "password",
+  indexName: "my_existing_index",
+});
+```
+
+#### Metadata Filtering
+
+Filter search results by node properties (requires Neo4j 5.18+):
+
+```typescript
+const results = await vectorStore.similaritySearch("query", 4, {
+  filter: {
+    category: "science",
+    year: { $gte: 2020 },
+  },
+});
+```
+
+Supported filter operators: `$eq`, `$ne`, `$lt`, `$lte`, `$gt`, `$gte`, `$in`, `$nin`, `$like`, `$ilike`, `$between`, `$and`, `$or`.
+
+### Neo4jChatMessageHistory
+
+Persist chat message history in a Neo4j database:
+
+```typescript
+import { Neo4jChatMessageHistory } from "@langchain/neo4j";
+import { HumanMessage, AIMessage } from "@langchain/core/messages";
+
+const history = await Neo4jChatMessageHistory.initialize({
+  url: "bolt://localhost:7687",
+  username: "neo4j",
+  password: "password",
+  sessionId: "my-session-id", // optional, auto-generated if not provided
+  windowSize: 5, // optional, defaults to 3
+});
+
+// Add messages
+await history.addMessage(new HumanMessage("Hello!"));
+await history.addMessage(new AIMessage("Hi there! How can I help you?"));
+
+// Retrieve messages
+const messages = await history.getMessages();
+
+// Clear history
+await history.clear();
+
+// Clean up
+await history.close();
+```
+
+### GraphCypherQAChain
+
+A chain for question-answering against a Neo4j graph database by generating Cypher statements. Requires `@langchain/classic` as an optional dependency.
+
+```typescript
+import { Neo4jGraph, GraphCypherQAChain } from "@langchain/neo4j";
+import { ChatOpenAI } from "@langchain/openai";
+
+const graph = await Neo4jGraph.initialize({
+  url: "bolt://localhost:7687",
+  username: "neo4j",
+  password: "password",
+});
+
+const llm = new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0 });
+
+const chain = GraphCypherQAChain.fromLLM({
+  graph,
+  llm,
+  returnIntermediateSteps: true,
+});
+
+const result = await chain.invoke({ query: "Who played in Pulp Fiction?" });
+console.log(result.result);
+```
+
+You can also use separate LLMs for Cypher generation and answer synthesis:
+
+```typescript
+const chain = GraphCypherQAChain.fromLLM({
+  graph,
+  cypherLLM: new ChatOpenAI({ model: "gpt-4o", temperature: 0 }),
+  qaLLM: new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0 }),
+});
+```
+
+### MemgraphGraph
+
+A subclass of `Neo4jGraph` for use with [Memgraph](https://memgraph.com/), which is compatible with the Bolt protocol:
+
+```typescript
+import { MemgraphGraph } from "@langchain/neo4j";
+
+const graph = await MemgraphGraph.initialize({
+  url: "bolt://localhost:7687",
+  username: "memgraph",
+  password: "password",
+});
+
+console.log(graph.getSchema());
+await graph.close();
+```
+
+## Security
+
+All database components in this package accept connection credentials. Make sure that the database connection uses credentials that are narrowly-scoped to only include necessary permissions. See the [LangChain security documentation](https://js.langchain.com/docs/security) for more information.
+
+## Migration from `@langchain/community`
+
+If you were previously using Neo4j integrations from `@langchain/community`, update your imports:
+
+```typescript
+// Before
+import { Neo4jGraph } from "@langchain/community/graphs/neo4j_graph";
+import { Neo4jVectorStore } from "@langchain/community/vectorstores/neo4j_vector";
+import { Neo4jChatMessageHistory } from "@langchain/community/stores/message/neo4j";
+import { GraphCypherQAChain } from "@langchain/community/chains/graph_qa/cypher";
+
+// After
+import {
+  Neo4jGraph,
+  Neo4jVectorStore,
+  Neo4jChatMessageHistory,
+  GraphCypherQAChain,
+} from "@langchain/neo4j";
+```
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build
+pnpm --filter @langchain/neo4j build
+
+# Run tests
+pnpm --filter @langchain/neo4j test
+
+# Lint
+pnpm --filter @langchain/neo4j lint
+```

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/dist/chains/graph_qa/cypher.cjs

@@ -0,0 +1,117 @@
+require("../../_virtual/_rolldown/runtime.cjs");
+const require_prompts = require("./prompts.cjs");
+let _langchain_classic_chains = require("@langchain/classic/chains");
+//#region src/chains/graph_qa/cypher.ts
+const INTERMEDIATE_STEPS_KEY = "intermediateSteps";
+/**
+* Chain for question-answering against a graph by generating Cypher statements.
+*
+* @example
+* ```typescript
+* const chain = new GraphCypherQAChain({
+*   llm: new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0 }),
+*   graph: new Neo4jGraph(),
+* });
+* const res = await chain.invoke("Who played in Pulp Fiction?");
+* ```
+*
+* @security
+* This chain will execute Cypher statements against the provided database.
+* Make sure that the database connection uses credentials
+* that are narrowly-scoped to only include necessary permissions.
+* Failure to do so may result in data corruption or loss, since the calling code
+* may attempt commands that would result in deletion, mutation of data
+* if appropriately prompted or reading sensitive data if such data is present in the database.
+* The best way to guard against such negative outcomes is to (as appropriate) limit the
+* permissions granted to the credentials used with this tool.
+*
+* See https://js.langchain.com/docs/security for more information.
+*/
+var GraphCypherQAChain = class GraphCypherQAChain extends _langchain_classic_chains.BaseChain {
+	graph;
+	cypherGenerationChain;
+	qaChain;
+	inputKey = "query";
+	outputKey = "result";
+	topK = 10;
+	returnDirect = false;
+	returnIntermediateSteps = false;
+	constructor(props) {
+		super(props);
+		const { graph, cypherGenerationChain, qaChain, inputKey, outputKey, topK, returnIntermediateSteps, returnDirect } = props;
+		this.graph = graph;
+		this.cypherGenerationChain = cypherGenerationChain;
+		this.qaChain = qaChain;
+		if (inputKey) this.inputKey = inputKey;
+		if (outputKey) this.outputKey = outputKey;
+		if (topK) this.topK = topK;
+		if (returnIntermediateSteps) this.returnIntermediateSteps = returnIntermediateSteps;
+		if (returnDirect) this.returnDirect = returnDirect;
+	}
+	_chainType() {
+		return "graph_cypher_chain";
+	}
+	get inputKeys() {
+		return [this.inputKey];
+	}
+	get outputKeys() {
+		return [this.outputKey];
+	}
+	static fromLLM(props) {
+		const { graph, qaPrompt = require_prompts.CYPHER_QA_PROMPT, cypherPrompt = require_prompts.CYPHER_GENERATION_PROMPT, llm, cypherLLM, qaLLM, returnIntermediateSteps = false, returnDirect = false } = props;
+		if (!cypherLLM && !llm) throw new Error("Either 'llm' or 'cypherLLM' parameters must be provided");
+		if (!qaLLM && !llm) throw new Error("Either 'llm' or 'qaLLM' parameters must be provided");
+		if (cypherLLM && qaLLM && llm) throw new Error("You can specify up to two of 'cypherLLM', 'qaLLM', and 'llm', but not all three simultaneously.");
+		const qaChain = new _langchain_classic_chains.LLMChain({
+			llm: qaLLM || llm,
+			prompt: qaPrompt
+		});
+		return new GraphCypherQAChain({
+			cypherGenerationChain: new _langchain_classic_chains.LLMChain({
+				llm: cypherLLM || llm,
+				prompt: cypherPrompt
+			}),
+			qaChain,
+			graph,
+			returnIntermediateSteps,
+			returnDirect
+		});
+	}
+	extractCypher(text) {
+		const matches = text.match(/```(.*?)```/s);
+		return matches ? matches[1] : text;
+	}
+	async _call(values, runManager) {
+		const callbacks = runManager?.getChild();
+		const question = values[this.inputKey];
+		const intermediateSteps = [];
+		const generatedCypher = await this.cypherGenerationChain.call({
+			question,
+			schema: this.graph.getSchema()
+		}, callbacks);
+		const extractedCypher = this.extractCypher(generatedCypher.text);
+		await runManager?.handleText(`Generated Cypher:\n`);
+		await runManager?.handleText(`${extractedCypher} green\n`);
+		intermediateSteps.push({ query: extractedCypher });
+		let chainResult;
+		const context = await this.graph.query(extractedCypher, { topK: this.topK });
+		if (this.returnDirect) chainResult = { [this.outputKey]: context };
+		else {
+			await runManager?.handleText("Full Context:\n");
+			await runManager?.handleText(`${context} green\n`);
+			intermediateSteps.push({ context });
+			const result = await this.qaChain.call({
+				question,
+				context: JSON.stringify(context)
+			}, callbacks);
+			chainResult = { [this.outputKey]: result[this.qaChain.outputKey] };
+		}
+		if (this.returnIntermediateSteps) chainResult[INTERMEDIATE_STEPS_KEY] = intermediateSteps;
+		return chainResult;
+	}
+};
+//#endregion
+exports.GraphCypherQAChain = GraphCypherQAChain;
+exports.INTERMEDIATE_STEPS_KEY = INTERMEDIATE_STEPS_KEY;
+
+//# sourceMappingURL=cypher.cjs.map

package/dist/chains/graph_qa/cypher.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cypher.cjs","names":["BaseChain","CYPHER_QA_PROMPT","CYPHER_GENERATION_PROMPT","LLMChain"],"sources":["../../../src/chains/graph_qa/cypher.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport { LLMChain, BaseChain, ChainInputs } from \"@langchain/classic/chains\";\nimport { Neo4jGraph } from \"../../graphs/neo4j_graph.js\";\nimport { CYPHER_GENERATION_PROMPT, CYPHER_QA_PROMPT } from \"./prompts.js\";\n\nexport const INTERMEDIATE_STEPS_KEY = \"intermediateSteps\";\n\nexport interface GraphCypherQAChainInput extends ChainInputs {\n  graph: Neo4jGraph;\n  cypherGenerationChain: LLMChain;\n  qaChain: LLMChain;\n  inputKey?: string;\n  outputKey?: string;\n  topK?: number;\n  returnIntermediateSteps?: boolean;\n  returnDirect?: boolean;\n}\n\nexport interface FromLLMInput {\n  graph: Neo4jGraph;\n  llm?: BaseLanguageModelInterface;\n  cypherLLM?: BaseLanguageModelInterface;\n  qaLLM?: BaseLanguageModelInterface;\n  qaPrompt?: BasePromptTemplate;\n  cypherPrompt?: BasePromptTemplate;\n  returnIntermediateSteps?: boolean;\n  returnDirect?: boolean;\n}\n\n/**\n * Chain for question-answering against a graph by generating Cypher statements.\n *\n * @example\n * ```typescript\n * const chain = new GraphCypherQAChain({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   graph: new Neo4jGraph(),\n * });\n * const res = await chain.invoke(\"Who played in Pulp Fiction?\");\n * ```\n *\n * @security\n * This chain will execute Cypher statements against the provided database.\n * Make sure that the database connection uses credentials\n * that are narrowly-scoped to only include necessary permissions.\n * Failure to do so may result in data corruption or loss, since the calling code\n * may attempt commands that would result in deletion, mutation of data\n * if appropriately prompted or reading sensitive data if such data is present in the database.\n * The best way to guard against such negative outcomes is to (as appropriate) limit the\n * permissions granted to the credentials used with this tool.\n *\n * See https://js.langchain.com/docs/security for more information.\n */\nexport class GraphCypherQAChain extends BaseChain {\n  private graph: Neo4jGraph;\n\n  private cypherGenerationChain: LLMChain;\n\n  private qaChain: LLMChain;\n\n  private inputKey = \"query\";\n\n  private outputKey = \"result\";\n\n  private topK = 10;\n\n  private returnDirect = false;\n\n  private returnIntermediateSteps = false;\n\n  constructor(props: GraphCypherQAChainInput) {\n    super(props);\n    const {\n      graph,\n      cypherGenerationChain,\n      qaChain,\n      inputKey,\n      outputKey,\n      topK,\n      returnIntermediateSteps,\n      returnDirect,\n    } = props;\n\n    this.graph = graph;\n    this.cypherGenerationChain = cypherGenerationChain;\n    this.qaChain = qaChain;\n\n    if (inputKey) {\n      this.inputKey = inputKey;\n    }\n    if (outputKey) {\n      this.outputKey = outputKey;\n    }\n    if (topK) {\n      this.topK = topK;\n    }\n    if (returnIntermediateSteps) {\n      this.returnIntermediateSteps = returnIntermediateSteps;\n    }\n    if (returnDirect) {\n      this.returnDirect = returnDirect;\n    }\n  }\n\n  _chainType() {\n    return \"graph_cypher_chain\" as const;\n  }\n\n  get inputKeys(): string[] {\n    return [this.inputKey];\n  }\n\n  get outputKeys(): string[] {\n    return [this.outputKey];\n  }\n\n  static fromLLM(props: FromLLMInput): GraphCypherQAChain {\n    const {\n      graph,\n      qaPrompt = CYPHER_QA_PROMPT,\n      cypherPrompt = CYPHER_GENERATION_PROMPT,\n      llm,\n      cypherLLM,\n      qaLLM,\n      returnIntermediateSteps = false,\n      returnDirect = false,\n    } = props;\n\n    if (!cypherLLM && !llm) {\n      throw new Error(\n        \"Either 'llm' or 'cypherLLM' parameters must be provided\"\n      );\n    }\n\n    if (!qaLLM && !llm) {\n      throw new Error(\"Either 'llm' or 'qaLLM' parameters must be provided\");\n    }\n\n    if (cypherLLM && qaLLM && llm) {\n      throw new Error(\n        \"You can specify up to two of 'cypherLLM', 'qaLLM', and 'llm', but not all three simultaneously.\"\n      );\n    }\n\n    const qaChain = new LLMChain({\n      llm: (qaLLM || llm) as BaseLanguageModelInterface,\n      prompt: qaPrompt,\n    });\n\n    const cypherGenerationChain = new LLMChain({\n      llm: (cypherLLM || llm) as BaseLanguageModelInterface,\n      prompt: cypherPrompt,\n    });\n\n    return new GraphCypherQAChain({\n      cypherGenerationChain,\n      qaChain,\n      graph,\n      returnIntermediateSteps,\n      returnDirect,\n    });\n  }\n\n  private extractCypher(text: string): string {\n    const pattern = /```(.*?)```/s;\n    const matches = text.match(pattern);\n    return matches ? matches[1] : text;\n  }\n\n  async _call(\n    values: ChainValues,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<ChainValues> {\n    const callbacks = runManager?.getChild();\n    const question = values[this.inputKey];\n\n    const intermediateSteps = [];\n\n    const generatedCypher = await this.cypherGenerationChain.call(\n      { question, schema: this.graph.getSchema() },\n      callbacks\n    );\n\n    const extractedCypher = this.extractCypher(generatedCypher.text);\n\n    await runManager?.handleText(`Generated Cypher:\\n`);\n    await runManager?.handleText(`${extractedCypher} green\\n`);\n\n    intermediateSteps.push({ query: extractedCypher });\n\n    let chainResult: ChainValues;\n    const context = await this.graph.query(extractedCypher, {\n      topK: this.topK,\n    });\n\n    if (this.returnDirect) {\n      chainResult = { [this.outputKey]: context };\n    } else {\n      await runManager?.handleText(\"Full Context:\\n\");\n      await runManager?.handleText(`${context} green\\n`);\n\n      intermediateSteps.push({ context });\n\n      const result = await this.qaChain.call(\n        { question, context: JSON.stringify(context) },\n        callbacks\n      );\n\n      chainResult = {\n        [this.outputKey]: result[this.qaChain.outputKey],\n      };\n    }\n\n    if (this.returnIntermediateSteps) {\n      chainResult[INTERMEDIATE_STEPS_KEY] = intermediateSteps;\n    }\n\n    return chainResult;\n  }\n}\n"],"mappings":";;;;AAQA,MAAa,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;AAgDtC,IAAa,qBAAb,MAAa,2BAA2BA,0BAAAA,UAAU;CAChD;CAEA;CAEA;CAEA,WAAmB;CAEnB,YAAoB;CAEpB,OAAe;CAEf,eAAuB;CAEvB,0BAAkC;CAElC,YAAY,OAAgC;AAC1C,QAAM,MAAM;EACZ,MAAM,EACJ,OACA,uBACA,SACA,UACA,WACA,MACA,yBACA,iBACE;AAEJ,OAAK,QAAQ;AACb,OAAK,wBAAwB;AAC7B,OAAK,UAAU;AAEf,MAAI,SACF,MAAK,WAAW;AAElB,MAAI,UACF,MAAK,YAAY;AAEnB,MAAI,KACF,MAAK,OAAO;AAEd,MAAI,wBACF,MAAK,0BAA0B;AAEjC,MAAI,aACF,MAAK,eAAe;;CAIxB,aAAa;AACX,SAAO;;CAGT,IAAI,YAAsB;AACxB,SAAO,CAAC,KAAK,SAAS;;CAGxB,IAAI,aAAuB;AACzB,SAAO,CAAC,KAAK,UAAU;;CAGzB,OAAO,QAAQ,OAAyC;EACtD,MAAM,EACJ,OACA,WAAWC,gBAAAA,kBACX,eAAeC,gBAAAA,0BACf,KACA,WACA,OACA,0BAA0B,OAC1B,eAAe,UACb;AAEJ,MAAI,CAAC,aAAa,CAAC,IACjB,OAAM,IAAI,MACR,0DACD;AAGH,MAAI,CAAC,SAAS,CAAC,IACb,OAAM,IAAI,MAAM,sDAAsD;AAGxE,MAAI,aAAa,SAAS,IACxB,OAAM,IAAI,MACR,kGACD;EAGH,MAAM,UAAU,IAAIC,0BAAAA,SAAS;GAC3B,KAAM,SAAS;GACf,QAAQ;GACT,CAAC;AAOF,SAAO,IAAI,mBAAmB;GAC5B,uBAN4B,IAAIA,0BAAAA,SAAS;IACzC,KAAM,aAAa;IACnB,QAAQ;IACT,CAAC;GAIA;GACA;GACA;GACA;GACD,CAAC;;CAGJ,cAAsB,MAAsB;EAE1C,MAAM,UAAU,KAAK,MADL,eACmB;AACnC,SAAO,UAAU,QAAQ,KAAK;;CAGhC,MAAM,MACJ,QACA,YACsB;EACtB,MAAM,YAAY,YAAY,UAAU;EACxC,MAAM,WAAW,OAAO,KAAK;EAE7B,MAAM,oBAAoB,EAAE;EAE5B,MAAM,kBAAkB,MAAM,KAAK,sBAAsB,KACvD;GAAE;GAAU,QAAQ,KAAK,MAAM,WAAW;GAAE,EAC5C,UACD;EAED,MAAM,kBAAkB,KAAK,cAAc,gBAAgB,KAAK;AAEhE,QAAM,YAAY,WAAW,sBAAsB;AACnD,QAAM,YAAY,WAAW,GAAG,gBAAgB,UAAU;AAE1D,oBAAkB,KAAK,EAAE,OAAO,iBAAiB,CAAC;EAElD,IAAI;EACJ,MAAM,UAAU,MAAM,KAAK,MAAM,MAAM,iBAAiB,EACtD,MAAM,KAAK,MACZ,CAAC;AAEF,MAAI,KAAK,aACP,eAAc,GAAG,KAAK,YAAY,SAAS;OACtC;AACL,SAAM,YAAY,WAAW,kBAAkB;AAC/C,SAAM,YAAY,WAAW,GAAG,QAAQ,UAAU;AAElD,qBAAkB,KAAK,EAAE,SAAS,CAAC;GAEnC,MAAM,SAAS,MAAM,KAAK,QAAQ,KAChC;IAAE;IAAU,SAAS,KAAK,UAAU,QAAQ;IAAE,EAC9C,UACD;AAED,iBAAc,GACX,KAAK,YAAY,OAAO,KAAK,QAAQ,YACvC;;AAGH,MAAI,KAAK,wBACP,aAAY,0BAA0B;AAGxC,SAAO"}

package/dist/chains/graph_qa/cypher.d.cts

@@ -0,0 +1,73 @@
+import { Neo4jGraph } from "../../graphs/neo4j_graph.cjs";
+import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { ChainValues } from "@langchain/core/utils/types";
+import { BasePromptTemplate } from "@langchain/core/prompts";
+import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
+import { BaseChain, ChainInputs, LLMChain } from "@langchain/classic/chains";
+
+//#region src/chains/graph_qa/cypher.d.ts
+declare const INTERMEDIATE_STEPS_KEY = "intermediateSteps";
+interface GraphCypherQAChainInput extends ChainInputs {
+  graph: Neo4jGraph;
+  cypherGenerationChain: LLMChain;
+  qaChain: LLMChain;
+  inputKey?: string;
+  outputKey?: string;
+  topK?: number;
+  returnIntermediateSteps?: boolean;
+  returnDirect?: boolean;
+}
+interface FromLLMInput {
+  graph: Neo4jGraph;
+  llm?: BaseLanguageModelInterface;
+  cypherLLM?: BaseLanguageModelInterface;
+  qaLLM?: BaseLanguageModelInterface;
+  qaPrompt?: BasePromptTemplate;
+  cypherPrompt?: BasePromptTemplate;
+  returnIntermediateSteps?: boolean;
+  returnDirect?: boolean;
+}
+/**
+ * Chain for question-answering against a graph by generating Cypher statements.
+ *
+ * @example
+ * ```typescript
+ * const chain = new GraphCypherQAChain({
+ *   llm: new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0 }),
+ *   graph: new Neo4jGraph(),
+ * });
+ * const res = await chain.invoke("Who played in Pulp Fiction?");
+ * ```
+ *
+ * @security
+ * This chain will execute Cypher statements against the provided database.
+ * Make sure that the database connection uses credentials
+ * that are narrowly-scoped to only include necessary permissions.
+ * Failure to do so may result in data corruption or loss, since the calling code
+ * may attempt commands that would result in deletion, mutation of data
+ * if appropriately prompted or reading sensitive data if such data is present in the database.
+ * The best way to guard against such negative outcomes is to (as appropriate) limit the
+ * permissions granted to the credentials used with this tool.
+ *
+ * See https://js.langchain.com/docs/security for more information.
+ */
+declare class GraphCypherQAChain extends BaseChain {
+  private graph;
+  private cypherGenerationChain;
+  private qaChain;
+  private inputKey;
+  private outputKey;
+  private topK;
+  private returnDirect;
+  private returnIntermediateSteps;
+  constructor(props: GraphCypherQAChainInput);
+  _chainType(): "graph_cypher_chain";
+  get inputKeys(): string[];
+  get outputKeys(): string[];
+  static fromLLM(props: FromLLMInput): GraphCypherQAChain;
+  private extractCypher;
+  _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;
+}
+//#endregion
+export { FromLLMInput, GraphCypherQAChain, GraphCypherQAChainInput, INTERMEDIATE_STEPS_KEY };
+//# sourceMappingURL=cypher.d.cts.map

package/dist/chains/graph_qa/cypher.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cypher.d.cts","names":[],"sources":["../../../src/chains/graph_qa/cypher.ts"],"mappings":";;;;;;;;cAQa,sBAAA;AAAA,UAEI,uBAAA,SAAgC,WAAA;EAC/C,KAAA,EAAO,UAAA;EACP,qBAAA,EAAuB,QAAA;EACvB,OAAA,EAAS,QAAA;EACT,QAAA;EACA,SAAA;EACA,IAAA;EACA,uBAAA;EACA,YAAA;AAAA;AAAA,UAGe,YAAA;EACf,KAAA,EAAO,UAAA;EACP,GAAA,GAAM,0BAAA;EACN,SAAA,GAAY,0BAAA;EACZ,KAAA,GAAQ,0BAAA;EACR,QAAA,GAAW,kBAAA;EACX,YAAA,GAAe,kBAAA;EACf,uBAAA;EACA,YAAA;AAAA;;;;;;;;;;AARF;;;;;;;;;;;;;;;cAmCa,kBAAA,SAA2B,SAAA;EAAA,QAC9B,KAAA;EAAA,QAEA,qBAAA;EAAA,QAEA,OAAA;EAAA,QAEA,QAAA;EAAA,QAEA,SAAA;EAAA,QAEA,IAAA;EAAA,QAEA,YAAA;EAAA,QAEA,uBAAA;EAER,WAAA,CAAY,KAAA,EAAO,uBAAA;EAkCnB,UAAA,CAAA;EAAA,IAII,SAAA,CAAA;EAAA,IAIA,UAAA,CAAA;EAAA,OAIG,OAAA,CAAQ,KAAA,EAAO,YAAA,GAAe,kBAAA;EAAA,QA+C7B,aAAA;EAMF,KAAA,CACJ,MAAA,EAAQ,WAAA,EACR,UAAA,GAAa,0BAAA,GACZ,OAAA,CAAQ,WAAA;AAAA"}

package/dist/chains/graph_qa/cypher.d.ts

@@ -0,0 +1,73 @@
+import { Neo4jGraph } from "../../graphs/neo4j_graph.js";
+import { BaseChain, ChainInputs, LLMChain } from "@langchain/classic/chains";
+import { BasePromptTemplate } from "@langchain/core/prompts";
+import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { ChainValues } from "@langchain/core/utils/types";
+import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
+
+//#region src/chains/graph_qa/cypher.d.ts
+declare const INTERMEDIATE_STEPS_KEY = "intermediateSteps";
+interface GraphCypherQAChainInput extends ChainInputs {
+  graph: Neo4jGraph;
+  cypherGenerationChain: LLMChain;
+  qaChain: LLMChain;
+  inputKey?: string;
+  outputKey?: string;
+  topK?: number;
+  returnIntermediateSteps?: boolean;
+  returnDirect?: boolean;
+}
+interface FromLLMInput {
+  graph: Neo4jGraph;
+  llm?: BaseLanguageModelInterface;
+  cypherLLM?: BaseLanguageModelInterface;
+  qaLLM?: BaseLanguageModelInterface;
+  qaPrompt?: BasePromptTemplate;
+  cypherPrompt?: BasePromptTemplate;
+  returnIntermediateSteps?: boolean;
+  returnDirect?: boolean;
+}
+/**
+ * Chain for question-answering against a graph by generating Cypher statements.
+ *
+ * @example
+ * ```typescript
+ * const chain = new GraphCypherQAChain({
+ *   llm: new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0 }),
+ *   graph: new Neo4jGraph(),
+ * });
+ * const res = await chain.invoke("Who played in Pulp Fiction?");
+ * ```
+ *
+ * @security
+ * This chain will execute Cypher statements against the provided database.
+ * Make sure that the database connection uses credentials
+ * that are narrowly-scoped to only include necessary permissions.
+ * Failure to do so may result in data corruption or loss, since the calling code
+ * may attempt commands that would result in deletion, mutation of data
+ * if appropriately prompted or reading sensitive data if such data is present in the database.
+ * The best way to guard against such negative outcomes is to (as appropriate) limit the
+ * permissions granted to the credentials used with this tool.
+ *
+ * See https://js.langchain.com/docs/security for more information.
+ */
+declare class GraphCypherQAChain extends BaseChain {
+  private graph;
+  private cypherGenerationChain;
+  private qaChain;
+  private inputKey;
+  private outputKey;
+  private topK;
+  private returnDirect;
+  private returnIntermediateSteps;
+  constructor(props: GraphCypherQAChainInput);
+  _chainType(): "graph_cypher_chain";
+  get inputKeys(): string[];
+  get outputKeys(): string[];
+  static fromLLM(props: FromLLMInput): GraphCypherQAChain;
+  private extractCypher;
+  _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;
+}
+//#endregion
+export { FromLLMInput, GraphCypherQAChain, GraphCypherQAChainInput, INTERMEDIATE_STEPS_KEY };
+//# sourceMappingURL=cypher.d.ts.map

package/dist/chains/graph_qa/cypher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cypher.d.ts","names":[],"sources":["../../../src/chains/graph_qa/cypher.ts"],"mappings":";;;;;;;;cAQa,sBAAA;AAAA,UAEI,uBAAA,SAAgC,WAAA;EAC/C,KAAA,EAAO,UAAA;EACP,qBAAA,EAAuB,QAAA;EACvB,OAAA,EAAS,QAAA;EACT,QAAA;EACA,SAAA;EACA,IAAA;EACA,uBAAA;EACA,YAAA;AAAA;AAAA,UAGe,YAAA;EACf,KAAA,EAAO,UAAA;EACP,GAAA,GAAM,0BAAA;EACN,SAAA,GAAY,0BAAA;EACZ,KAAA,GAAQ,0BAAA;EACR,QAAA,GAAW,kBAAA;EACX,YAAA,GAAe,kBAAA;EACf,uBAAA;EACA,YAAA;AAAA;;;;;;;;;;AARF;;;;;;;;;;;;;;;cAmCa,kBAAA,SAA2B,SAAA;EAAA,QAC9B,KAAA;EAAA,QAEA,qBAAA;EAAA,QAEA,OAAA;EAAA,QAEA,QAAA;EAAA,QAEA,SAAA;EAAA,QAEA,IAAA;EAAA,QAEA,YAAA;EAAA,QAEA,uBAAA;EAER,WAAA,CAAY,KAAA,EAAO,uBAAA;EAkCnB,UAAA,CAAA;EAAA,IAII,SAAA,CAAA;EAAA,IAIA,UAAA,CAAA;EAAA,OAIG,OAAA,CAAQ,KAAA,EAAO,YAAA,GAAe,kBAAA;EAAA,QA+C7B,aAAA;EAMF,KAAA,CACJ,MAAA,EAAQ,WAAA,EACR,UAAA,GAAa,0BAAA,GACZ,OAAA,CAAQ,WAAA;AAAA"}