langchain 0.2.2 → 0.2.3-rc.0

package/dist/chains/tests/sequential_chain.int.test.js

@@ -0,0 +1,88 @@
+import { test } from "@jest/globals";
+import { OpenAI, ChatOpenAI } from "@langchain/openai";
+import { PromptTemplate } from "@langchain/core/prompts";
+import { LLMChain } from "../llm_chain.js";
+import { SequentialChain } from "../sequential_chain.js";
+test("Test SequentialChain example usage", async () => {
+    // This is an LLMChain to write a synopsis given a title of a play and the era it is set in.
+    const llm = new OpenAI({ temperature: 0 });
+    const template = `You are a playwright. Given the title of play and the era it is set in, it is your job to write a synopsis for that title.
+
+  Title: {title}
+  Era: {era}
+  Playwright: This is a synopsis for the above play:`;
+    const promptTemplate = new PromptTemplate({
+        template,
+        inputVariables: ["title", "era"],
+    });
+    const synopsisChain = new LLMChain({
+        llm,
+        prompt: promptTemplate,
+        outputKey: "synopsis",
+    });
+    // This is an LLMChain to write a review of a play given a synopsis.
+    const reviewLLM = new OpenAI({ temperature: 0 });
+    const reviewTemplate = `You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.
+    
+     Play Synopsis:
+     {synopsis}
+     Review from a New York Times play critic of the above play:`;
+    const reviewPromptTemplate = new PromptTemplate({
+        template: reviewTemplate,
+        inputVariables: ["synopsis"],
+    });
+    const reviewChain = new LLMChain({
+        llm: reviewLLM,
+        prompt: reviewPromptTemplate,
+        outputKey: "review",
+    });
+    const overallChain = new SequentialChain({
+        chains: [synopsisChain, reviewChain],
+        inputVariables: ["era", "title"],
+        // Here we return multiple variables
+        outputVariables: ["synopsis", "review"],
+        verbose: true,
+    });
+    const review = await overallChain.call({
+        title: "Tragedy at sunset on the beach",
+        era: "Victorian England",
+    });
+    expect(review.review.toLowerCase()).toContain("tragedy at sunset on the beach");
+});
+test.skip("Test SequentialChain serialize/deserialize", async () => {
+    const llm1 = new ChatOpenAI();
+    const template1 = `Echo back "{foo} {bar}"`;
+    const promptTemplate1 = new PromptTemplate({
+        template: template1,
+        inputVariables: ["foo", "bar"],
+    });
+    const chain1 = new LLMChain({
+        llm: llm1,
+        prompt: promptTemplate1,
+        outputKey: "baz",
+    });
+    const llm2 = new ChatOpenAI();
+    const template2 = `Echo back "{baz}"`;
+    const promptTemplate2 = new PromptTemplate({
+        template: template2,
+        inputVariables: ["baz"],
+    });
+    const chain2 = new LLMChain({
+        llm: llm2,
+        prompt: promptTemplate2,
+    });
+    const sampleSequentialChain = new SequentialChain({
+        chains: [chain1, chain2],
+        inputVariables: ["foo", "bar"],
+        outputVariables: ["text"],
+        verbose: true,
+    });
+    const serializedChain = sampleSequentialChain.serialize();
+    expect(serializedChain._type).toEqual("sequential_chain");
+    expect(serializedChain.chains.length).toEqual(2);
+    const deserializedChain = await SequentialChain.deserialize(serializedChain);
+    expect(deserializedChain.chains.length).toEqual(2);
+    expect(deserializedChain._chainType).toEqual("sequential_chain");
+    const review = await deserializedChain.call({ foo: "test1", bar: "test2" });
+    expect(review.trim()).toMatchInlineSnapshot(`"test1 test2"`);
+});

package/dist/chains/tests/sequential_chain.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/chains/tests/sequential_chain.test.js

@@ -0,0 +1,295 @@
+import { test, expect } from "@jest/globals";
+import { BaseLLM } from "@langchain/core/language_models/llms";
+import { PromptTemplate } from "@langchain/core/prompts";
+import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import { ChatMessageHistory } from "../../stores/message/in_memory.js";
+import { LLMChain } from "../llm_chain.js";
+import { SequentialChain } from "../sequential_chain.js";
+import { BufferMemory } from "../../memory/buffer_memory.js";
+class FakeLLM1 extends BaseLLM {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "nrMapCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "nrReduceCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    _llmType() {
+        return "fake_1";
+    }
+    async _generate(_prompts) {
+        return {
+            generations: [
+                [
+                    {
+                        text: "The answer is XXX.",
+                    },
+                ],
+            ],
+        };
+    }
+}
+class FakeLLM2 extends BaseLLM {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "nrMapCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "nrReduceCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    _llmType() {
+        return "fake_2";
+    }
+    async _generate(prompts) {
+        let response = "I don't know what you are talking about.";
+        if (prompts[0].includes("XXX")) {
+            response = "final answer";
+        }
+        return {
+            generations: [
+                [
+                    {
+                        text: response,
+                    },
+                ],
+            ],
+        };
+    }
+}
+class FakeLLM3 extends BaseLLM {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "nrMapCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "nrReduceCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    _llmType() {
+        return "fake_2";
+    }
+    async _generate(prompts) {
+        const inputNumber = +prompts[0];
+        let response = "Not a number!!!";
+        if (prompts[0].startsWith("Final Answer: ")) {
+            [response] = prompts;
+        }
+        else if (!Number.isNaN(inputNumber)) {
+            response = (inputNumber + 1).toString();
+        }
+        return {
+            generations: [
+                [
+                    {
+                        text: response,
+                    },
+                ],
+            ],
+        };
+    }
+}
+test("Test SequentialChain", async () => {
+    const model1 = new FakeLLM1({});
+    const model2 = new FakeLLM2({});
+    const template1 = "Some arbitrary template with fake {input1} and {input2}.";
+    const template2 = "Some arbitrary template with fake {input3}.";
+    const prompt1 = new PromptTemplate({
+        template: template1,
+        inputVariables: ["input1", "input2"],
+    });
+    const prompt2 = new PromptTemplate({
+        template: template2,
+        inputVariables: ["input3"],
+    });
+    const chain1 = new LLMChain({
+        llm: model1,
+        prompt: prompt1,
+        outputKey: "input3",
+    });
+    const chain2 = new LLMChain({ llm: model2, prompt: prompt2 });
+    const combinedChain = new SequentialChain({
+        chains: [chain1, chain2],
+        inputVariables: ["input1", "input2"],
+        outputVariables: ["text"],
+    });
+    const response = await combinedChain.invoke({
+        input1: "test1",
+        input2: "test2",
+    });
+    expect(response).toMatchInlineSnapshot(`
+    {
+      "text": "final answer",
+    }
+  `);
+});
+test("Test SequentialChain input/output chains' validation", () => {
+    const model1 = new FakeLLM1({});
+    const template1 = "Some arbitrary template with fake {input1} and {input2}.";
+    const prompt1 = new PromptTemplate({
+        template: template1,
+        inputVariables: ["input1", "input2"],
+    });
+    const chain1 = new LLMChain({
+        llm: model1,
+        prompt: prompt1,
+        outputKey: "input3",
+    });
+    const model2 = new FakeLLM2({});
+    const template2 = "Some arbitrary template with fake {input3}.";
+    const prompt2 = new PromptTemplate({
+        template: template2,
+        inputVariables: ["input3"],
+    });
+    const chain2 = new LLMChain({ llm: model2, prompt: prompt2 });
+    expect(() => {
+        /* eslint-disable no-new */
+        new SequentialChain({
+            chains: [chain1, chain2],
+            inputVariables: ["input1"],
+            outputVariables: ["text"],
+        });
+    }).toThrowErrorMatchingInlineSnapshot(`"Missing variables for chain "llm": "input2". Only got the following variables: "input1"."`);
+    expect(() => {
+        /* eslint-disable no-new */
+        new SequentialChain({
+            chains: [chain1, chain2],
+            inputVariables: ["input1", "input2"],
+            outputVariables: ["nonexistent"],
+        });
+    }).toThrowErrorMatchingInlineSnapshot(`"The following output variables were expected to be in the final chain output but were not found: "nonexistent"."`);
+});
+test("Test SequentialChain chains' intermediate variables validation", () => {
+    const model1 = new FakeLLM1({});
+    const template1 = "Some arbitrary template with fake {input1} and {input2}.";
+    const prompt1 = new PromptTemplate({
+        template: template1,
+        inputVariables: ["input1", "input2"],
+    });
+    const chain1 = new LLMChain({
+        llm: model1,
+        prompt: prompt1,
+        outputKey: "nonexistent",
+    });
+    const model2 = new FakeLLM2({});
+    const template2 = "Some arbitrary template with fake {input3}.";
+    const prompt2 = new PromptTemplate({
+        template: template2,
+        inputVariables: ["input3"],
+    });
+    const chain2 = new LLMChain({ llm: model2, prompt: prompt2 });
+    expect(() => {
+        /* eslint-disable no-new */
+        new SequentialChain({
+            chains: [chain1, chain2],
+            inputVariables: ["input1", "input2"],
+            outputVariables: ["text"],
+        });
+    }).toThrowErrorMatchingInlineSnapshot(`"Missing variables for chain "llm": "input3". Only got the following variables: "input1", "input2", "nonexistent"."`);
+});
+test("Test SequentialChain chains passes all outputs", async () => {
+    const model1 = new FakeLLM3({});
+    const template1 = "{input1}";
+    const prompt1 = new PromptTemplate({
+        template: template1,
+        inputVariables: ["input1"],
+    });
+    const chain1 = new LLMChain({
+        llm: model1,
+        prompt: prompt1,
+        outputKey: "input2",
+    });
+    const model2 = new FakeLLM3({});
+    const template2 = "{input2}";
+    const prompt2 = new PromptTemplate({
+        template: template2,
+        inputVariables: ["input2"],
+    });
+    const chain2 = new LLMChain({
+        llm: model2,
+        prompt: prompt2,
+        outputKey: "input3",
+    });
+    const model3 = new FakeLLM3({});
+    const template3 = "Final Answer: {input1} {input2} {input3}.";
+    const prompt3 = new PromptTemplate({
+        template: template3,
+        inputVariables: ["input1", "input2", "input3"],
+    });
+    const chain3 = new LLMChain({ llm: model3, prompt: prompt3 });
+    const combinedChain = new SequentialChain({
+        chains: [chain1, chain2, chain3],
+        inputVariables: ["input1"],
+        outputVariables: ["text"],
+    });
+    expect(await combinedChain.invoke({
+        input1: "1",
+    })).toMatchInlineSnapshot(`
+  {
+    "text": "Final Answer: 1 2 3.",
+  }
+`);
+});
+test("Test SequentialChain for memory on one of the sub-chains", async () => {
+    const model1 = new FakeLLM1({});
+    const template1 = "Some arbitrary template with fake {input1}.";
+    const prompt1 = new PromptTemplate({
+        template: template1,
+        inputVariables: ["input1"],
+    });
+    const chain1 = new LLMChain({
+        llm: model1,
+        prompt: prompt1,
+        outputKey: "input2",
+    });
+    const memory = new BufferMemory({
+        memoryKey: "chat",
+        chatHistory: new ChatMessageHistory([
+            new HumanMessage("Hello"),
+            new AIMessage("Hi"),
+        ]),
+        inputKey: "input2",
+    });
+    const model2 = new FakeLLM3({});
+    const template2 = "Final Answer: \n{chat}\n{input2}";
+    const prompt2 = new PromptTemplate({
+        template: template2,
+        inputVariables: ["input2", "chat"],
+    });
+    const chain2 = new LLMChain({
+        llm: model2,
+        prompt: prompt2,
+        memory,
+    });
+    const combinedChain = new SequentialChain({
+        chains: [chain1, chain2],
+        inputVariables: ["input1"],
+        outputVariables: ["text"],
+    });
+    const result = await combinedChain.invoke({ input1: "test1" });
+    expect(result).toMatchObject({
+        text: "Final Answer: \nHuman: Hello\nAI: Hi\nThe answer is XXX.",
+    });
+});

package/dist/chains/tests/simple_sequential_chain.int.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/chains/tests/simple_sequential_chain.int.test.js

@@ -0,0 +1,81 @@
+import { test } from "@jest/globals";
+import { OpenAI, ChatOpenAI } from "@langchain/openai";
+import { PromptTemplate } from "@langchain/core/prompts";
+import { LLMChain } from "../llm_chain.js";
+import { SimpleSequentialChain } from "../sequential_chain.js";
+import { BufferMemory } from "../../memory/buffer_memory.js";
+test("Test SimpleSequentialChain example usage", async () => {
+    // This is an LLMChain to write a synopsis given a title of a play.
+    const llm = new OpenAI({ temperature: 0 });
+    const template = `You are a playwright. Given the title of play, it is your job to write a synopsis for that title.
+    
+     Title: {title}
+     Playwright: This is a synopsis for the above play:`;
+    const promptTemplate = new PromptTemplate({
+        template,
+        inputVariables: ["title"],
+    });
+    const synopsisChain = new LLMChain({ llm, prompt: promptTemplate });
+    // This is an LLMChain to write a review of a play given a synopsis.
+    const reviewLLM = new OpenAI({ temperature: 0 });
+    const reviewTemplate = `You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.
+    
+     Play Synopsis:
+     {synopsis}
+     Review from a New York Times play critic of the above play:`;
+    const reviewPromptTemplate = new PromptTemplate({
+        template: reviewTemplate,
+        inputVariables: ["synopsis"],
+    });
+    const reviewChain = new LLMChain({
+        llm: reviewLLM,
+        prompt: reviewPromptTemplate,
+    });
+    const overallChain = new SimpleSequentialChain({
+        chains: [synopsisChain, reviewChain],
+        verbose: true,
+    });
+    const review = await overallChain.run("Tragedy at sunset on the beach");
+    expect(review.trim().toLowerCase()).toContain("tragedy at sunset on the beach");
+});
+test("Test SimpleSequentialChain example usage", async () => {
+    // This is an LLMChain to write a synopsis given a title of a play.
+    const llm = new ChatOpenAI({ temperature: 0 });
+    const template = `You are a playwright. Given the title of play, it is your job to write a synopsis for that title.
+    
+     {history}
+     Title: {title}
+     Playwright: This is a synopsis for the above play:`;
+    const promptTemplate = new PromptTemplate({
+        template,
+        inputVariables: ["title", "history"],
+    });
+    const synopsisChain = new LLMChain({
+        llm,
+        prompt: promptTemplate,
+        memory: new BufferMemory(),
+    });
+    // This is an LLMChain to write a review of a play given a synopsis.
+    const reviewLLM = new ChatOpenAI({ temperature: 0 });
+    const reviewTemplate = `You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.
+    
+     Play Synopsis:
+     {synopsis}
+     Review from a New York Times play critic of the above play:`;
+    const reviewPromptTemplate = new PromptTemplate({
+        template: reviewTemplate,
+        inputVariables: ["synopsis"],
+    });
+    const reviewChain = new LLMChain({
+        llm: reviewLLM,
+        prompt: reviewPromptTemplate,
+    });
+    const overallChain = new SimpleSequentialChain({
+        chains: [synopsisChain, reviewChain],
+        verbose: true,
+    });
+    await expect(() => overallChain.call({
+        input: "Tragedy at sunset on the beach",
+        signal: AbortSignal.timeout(1000),
+    })).rejects.toThrow("AbortError");
+});

package/dist/chains/tests/simple_sequential_chain.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/chains/tests/simple_sequential_chain.test.js

@@ -0,0 +1,128 @@
+import { test, expect } from "@jest/globals";
+import { BaseLLM } from "@langchain/core/language_models/llms";
+import { PromptTemplate } from "@langchain/core/prompts";
+import { VectorStoreRetriever } from "@langchain/core/vectorstores";
+import { FakeEmbeddings } from "@langchain/core/utils/testing";
+import { LLMChain } from "../llm_chain.js";
+import { SimpleSequentialChain } from "../sequential_chain.js";
+import { AnalyzeDocumentChain } from "../analyze_documents_chain.js";
+import { ConversationalRetrievalQAChain } from "../conversational_retrieval_chain.js";
+import { MemoryVectorStore } from "../../vectorstores/memory.js";
+class FakeLLM1 extends BaseLLM {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "nrMapCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "nrReduceCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    _llmType() {
+        return "fake_1";
+    }
+    async _generate(_prompts) {
+        return {
+            generations: [
+                [
+                    {
+                        text: "The answer is XXX.",
+                    },
+                ],
+            ],
+        };
+    }
+}
+class FakeLLM2 extends BaseLLM {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "nrMapCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "nrReduceCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    _llmType() {
+        return "fake_2";
+    }
+    async _generate(prompts) {
+        let response = "I don't know what you are talking about.";
+        if (prompts[0].includes("XXX")) {
+            response = "final answer";
+        }
+        return {
+            generations: [
+                [
+                    {
+                        text: response,
+                    },
+                ],
+            ],
+        };
+    }
+}
+test("Test SimpleSequentialChain", async () => {
+    const model1 = new FakeLLM1({});
+    const model2 = new FakeLLM2({});
+    const template = "Some arbitrary template with fake {input}.";
+    const prompt = new PromptTemplate({ template, inputVariables: ["input"] });
+    const chain1 = new LLMChain({ llm: model1, prompt });
+    const chain2 = new LLMChain({ llm: model2, prompt });
+    const combinedChain = new SimpleSequentialChain({ chains: [chain1, chain2] });
+    const response = await combinedChain.run("initial question");
+    expect(response).toEqual("final answer");
+});
+test("Test SimpleSequentialChain input chains' single input validation", async () => {
+    const model1 = new FakeLLM1({});
+    const model2 = new FakeLLM2({});
+    const template = "Some arbitrary template with fake {input1} and {input2}.";
+    const prompt = new PromptTemplate({
+        template,
+        inputVariables: ["input1", "input2"],
+    });
+    const chain1 = new LLMChain({ llm: model1, prompt });
+    const chain2 = new LLMChain({ llm: model2, prompt });
+    expect(() => {
+        /* eslint-disable no-new */
+        new SimpleSequentialChain({ chains: [chain1, chain2] });
+    }).toThrowErrorMatchingInlineSnapshot(`"Chains used in SimpleSequentialChain should all have one input, got 2 for llm."`);
+});
+test("Test SimpleSequentialChain input chains' single ouput validation", async () => {
+    const model1 = new FakeLLM1({});
+    const fakeEmbeddings = new FakeEmbeddings();
+    const anyStore = new MemoryVectorStore(fakeEmbeddings);
+    const retriever = new VectorStoreRetriever({
+        vectorStore: anyStore,
+    });
+    const template = "Some arbitrary template with fake {input}.";
+    const prompt = new PromptTemplate({ template, inputVariables: ["input"] });
+    const chain1 = new LLMChain({ llm: model1, prompt });
+    const chain2 = new ConversationalRetrievalQAChain({
+        retriever,
+        combineDocumentsChain: chain1,
+        questionGeneratorChain: chain1,
+        returnSourceDocuments: true,
+    });
+    // Chain below is is not meant to work in a real-life scenario.
+    // It's only combined this way to get one input/multiple outputs chain.
+    const multipleOutputChain = new AnalyzeDocumentChain({
+        combineDocumentsChain: chain2,
+    });
+    expect(() => {
+        /* eslint-disable no-new */
+        new SimpleSequentialChain({ chains: [chain1, multipleOutputChain] });
+    }).toThrowErrorMatchingInlineSnapshot(`"Chains used in SimpleSequentialChain should all have one output, got 2 for analyze_document_chain."`);
+});

package/dist/chains/tests/sql_db_chain.int.test.d.ts

@@ -0,0 +1 @@
+export {};