langchain 0.2.2 → 0.2.3-rc.0

package/dist/agents/tests/structured_output_runnables.int.test.js

@@ -0,0 +1,112 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+import fs from "fs";
+import { z } from "zod";
+import { OpenAIEmbeddings, ChatOpenAI } from "@langchain/openai";
+import { convertToOpenAIFunction } from "@langchain/core/utils/function_calling";
+import { RunnableSequence } from "@langchain/core/runnables";
+import { ChatPromptTemplate, MessagesPlaceholder, } from "@langchain/core/prompts";
+import { createRetrieverTool } from "../toolkits/index.js";
+import { RecursiveCharacterTextSplitter } from "../../text_splitter.js";
+import { MemoryVectorStore } from "../../vectorstores/memory.js";
+import { AgentExecutor } from "../executor.js";
+import { formatForOpenAIFunctions } from "../format_scratchpad/openai_functions.js";
+/** Define a custom structured output parser. */
+const structuredOutputParser = (output) => {
+    if (typeof output.content !== "string") {
+        throw new Error("Cannot parse non-string output.");
+    }
+    if (output.additional_kwargs.function_call === undefined) {
+        return { returnValues: { output: output.content }, log: output.content };
+    }
+    const functionCall = output.additional_kwargs.function_call;
+    const name = functionCall?.name;
+    const inputs = functionCall?.arguments;
+    console.log(functionCall);
+    const jsonInput = JSON.parse(inputs);
+    if (name === "response") {
+        return { returnValues: { ...jsonInput }, log: output.content };
+    }
+    return {
+        tool: name,
+        toolInput: jsonInput,
+        log: output.content,
+    };
+};
+test("Pass custom structured output parsers", async () => {
+    /** Read text file & embed documents */
+    const text = fs.readFileSync("../examples/state_of_the_union.txt", "utf8");
+    const textSplitter = new RecursiveCharacterTextSplitter({ chunkSize: 1000 });
+    let docs = await textSplitter.createDocuments([text]);
+    // Add fake source information
+    docs = docs.map((doc, i) => ({
+        ...doc,
+        metadata: {
+            page_chunk: i,
+        },
+    }));
+    /** Initialize docs & create retriever */
+    const vectorStore = await MemoryVectorStore.fromDocuments(docs, new OpenAIEmbeddings());
+    const retriever = vectorStore.asRetriever();
+    /** Instantiate the LLM */
+    const llm = new ChatOpenAI({});
+    /** Define the prompt template */
+    const prompt = ChatPromptTemplate.fromMessages([
+        ["system", "You are a helpful assistant"],
+        new MessagesPlaceholder("agent_scratchpad"),
+        ["user", "{input}"],
+    ]);
+    /** Define the response schema */
+    const responseSchema = z.object({
+        answer: z.string().describe("The final answer to respond to the user"),
+        sources: z
+            .array(z.string())
+            .describe("List of page chunks that contain answer to the question. Only include a page chunk if it contains relevant information"),
+    });
+    /** Create the response function */
+    const responseOpenAIFunction = {
+        name: "response",
+        description: "Return the response to the user",
+        parameters: zodToJsonSchema(responseSchema),
+    };
+    /** Convert retriever into a tool */
+    const retrieverTool = createRetrieverTool(retriever, {
+        name: "state-of-union-retriever",
+        description: "Query a retriever to get information about state of the union address",
+    });
+    /** Bind both retriever and response functions to LLM */
+    const llmWithTools = llm.bind({
+        functions: [convertToOpenAIFunction(retrieverTool), responseOpenAIFunction],
+    });
+    /** Create the runnable */
+    const runnableAgent = RunnableSequence.from([
+        {
+            input: (i) => i.input,
+            agent_scratchpad: (i) => formatForOpenAIFunctions(i.steps),
+        },
+        prompt,
+        llmWithTools,
+        structuredOutputParser,
+    ]);
+    /** Create the agent by passing in the runnable & tools */
+    const executor = AgentExecutor.fromAgentAndTools({
+        agent: runnableAgent,
+        tools: [retrieverTool],
+    });
+    /** Call invoke on the agent */
+    const res = await executor.invoke({
+        input: "what did the president say about kentaji brown jackson",
+    });
+    console.log({
+        res,
+    });
+    /**
+      {
+        res: {
+          answer: 'President mentioned that he nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. He described her as one of our nation’s top legal minds and stated that she will continue Justice Breyer’s legacy of excellence.',
+          sources: [
+            'And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans.'
+          ]
+        }
+      }
+     */
+});

package/dist/agents/toolkits/tests/conversational_retrieval.int.test.d.ts

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

package/dist/agents/toolkits/tests/conversational_retrieval.int.test.js

@@ -0,0 +1,41 @@
+import { test } from "@jest/globals";
+import { OpenAIEmbeddings, ChatOpenAI } from "@langchain/openai";
+import { MemoryVectorStore } from "../../../vectorstores/memory.js";
+import { createConversationalRetrievalAgent } from "../conversational_retrieval/openai_functions.js";
+import { createRetrieverTool } from "../conversational_retrieval/tool.js";
+test("Test ConversationalRetrievalAgent", async () => {
+    const vectorStore = await MemoryVectorStore.fromTexts([
+        "LangCo made $10000 in July",
+        "LangCo made $20 in August",
+        "Foo is red",
+        "Bar is red",
+        "Buildings are made out of brick",
+        "Mitochondria is the powerhouse of the cell",
+    ], [{ id: 2 }, { id: 1 }, { id: 3 }, { id: 4 }, { id: 5 }], new OpenAIEmbeddings());
+    const llm = new ChatOpenAI({});
+    const tools = [
+        createRetrieverTool(vectorStore.asRetriever(), {
+            name: "search_LangCo_knowledge",
+            description: "Searches for and returns documents regarding LangCo",
+        }),
+    ];
+    const executor = await createConversationalRetrievalAgent(llm, tools, {
+        verbose: true,
+    });
+    const result = await executor.invoke({
+        input: "Hi, I'm Bob!",
+    });
+    console.log(result);
+    const result2 = await executor.invoke({
+        input: "What's my name?",
+    });
+    console.log(result2);
+    const result3 = await executor.invoke({
+        input: "How much money did LangCo make in July?",
+    });
+    console.log(result3);
+    const result4 = await executor.invoke({
+        input: "How about in August?",
+    });
+    console.log(result4);
+});

package/dist/cache/tests/file_system.int.test.d.ts

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

package/dist/cache/tests/file_system.int.test.js

@@ -0,0 +1,32 @@
+import { test, expect } from "@jest/globals";
+import fs from "node:fs/promises";
+import path from "node:path";
+import * as os from "node:os";
+import { OpenAI, ChatOpenAI } from "@langchain/openai";
+import { LocalFileCache } from "../file_system.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let tmpDir;
+describe("Test LocalFileCache", () => {
+    beforeAll(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "langchain-"));
+    });
+    afterAll(async () => {
+        await fs.rm(tmpDir, { recursive: true });
+    });
+    test("FSCache with an LLM", async () => {
+        const cache = await LocalFileCache.create(tmpDir);
+        const model = new OpenAI({ cache });
+        const response1 = await model.invoke("What is something random?");
+        const response2 = await model.invoke("What is something random?");
+        expect(response1).toEqual(response2);
+    });
+    test("FSCache with a chat model", async () => {
+        const cache = await LocalFileCache.create(tmpDir);
+        const model = new ChatOpenAI({ cache });
+        const response1 = await model.invoke("What is something random?");
+        const response2 = await model.invoke("What is something random?");
+        expect(response1).not.toBeUndefined();
+        console.log(response1, response2);
+        expect(response1).toEqual(response2);
+    });
+});

package/dist/chains/openai_functions/tests/create_runnable_chains.int.test.d.ts

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

package/dist/chains/openai_functions/tests/create_runnable_chains.int.test.js

@@ -0,0 +1,139 @@
+import { z } from "zod";
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { ChatOpenAI } from "@langchain/openai";
+import { expect, test } from "@jest/globals";
+import { JsonOutputFunctionsParser } from "../../../output_parsers/openai_functions.js";
+import { createOpenAIFnRunnable, createStructuredOutputRunnable, } from "../base.js";
+const personJSONSchema = {
+    title: "Person",
+    description: "Identifying information about a person.",
+    type: "object",
+    properties: {
+        name: { title: "Name", description: "The person's name", type: "string" },
+        age: { title: "Age", description: "The person's age", type: "integer" },
+        fav_food: {
+            title: "Fav Food",
+            description: "The person's favorite food",
+            type: "string",
+        },
+    },
+    required: ["name", "age"],
+};
+const personDetailsFunction = {
+    name: "get_person_details",
+    description: "Get details about a person",
+    parameters: personJSONSchema,
+};
+const weatherFunction = {
+    name: "get_weather",
+    description: "Get the weather for a location",
+    parameters: {
+        title: "Location",
+        description: "The location to get the weather for.",
+        type: "object",
+        properties: {
+            state: {
+                title: "State",
+                description: "The location's state",
+                type: "string",
+            },
+            city: {
+                title: "City",
+                description: "The location's city",
+                type: "string",
+            },
+            zip_code: {
+                title: "Zip Code",
+                description: "The locations's zip code",
+                type: "string",
+            },
+        },
+        required: ["state", "city"],
+    },
+};
+test("createStructuredOutputRunnable works with Zod", async () => {
+    const model = new ChatOpenAI();
+    const prompt = ChatPromptTemplate.fromMessages([
+        ["human", "Human description: {description}"],
+    ]);
+    const zodSchema = z.object({
+        person: z.object({
+            name: z.string(),
+            age: z.string(),
+            fav_food: z.optional(z.string()),
+        }),
+    });
+    const outputParser = new JsonOutputFunctionsParser();
+    const runnable = createStructuredOutputRunnable({
+        outputSchema: zodSchema,
+        llm: model,
+        prompt,
+        outputParser,
+    });
+    const response = await runnable.invoke({
+        description: "My name's John Doe and I'm 30 years old. My favorite kind of food are chocolate chip cookies.",
+    });
+    console.log(response);
+    expect("person" in response).toBe(true);
+    expect("name" in response.person).toBe(true);
+    expect("age" in response.person).toBe(true);
+});
+test("createStructuredOutputRunnable works with JSON schema", async () => {
+    const model = new ChatOpenAI();
+    const prompt = ChatPromptTemplate.fromMessages([
+        ["human", "Human description: {description}"],
+    ]);
+    const outputParser = new JsonOutputFunctionsParser();
+    const runnable = createStructuredOutputRunnable({
+        outputSchema: personJSONSchema,
+        llm: model,
+        prompt,
+        outputParser,
+    });
+    const response = await runnable.invoke({
+        description: "My name's John Doe and I'm 30 years old. My favorite kind of food are chocolate chip cookies.",
+    });
+    console.log(response);
+    expect("name" in response).toBe(true);
+    expect("age" in response).toBe(true);
+});
+test("createOpenAIFnRunnable works", async () => {
+    const model = new ChatOpenAI();
+    const prompt = ChatPromptTemplate.fromMessages([
+        ["human", "Human description: {description}"],
+    ]);
+    const outputParser = new JsonOutputFunctionsParser();
+    const runnable = createOpenAIFnRunnable({
+        functions: [personDetailsFunction],
+        llm: model,
+        prompt,
+        enforceSingleFunctionUsage: true,
+        outputParser,
+    });
+    const response = await runnable.invoke({
+        description: "My name's John Doe and I'm 30 years old. My favorite kind of food are chocolate chip cookies.",
+    });
+    console.log(response);
+    expect("name" in response).toBe(true);
+    expect("age" in response).toBe(true);
+});
+test("createOpenAIFnRunnable works with multiple functions", async () => {
+    const model = new ChatOpenAI();
+    const prompt = ChatPromptTemplate.fromMessages([
+        ["human", "Question: {question}"],
+    ]);
+    const outputParser = new JsonOutputFunctionsParser();
+    const runnable = createOpenAIFnRunnable({
+        functions: [personDetailsFunction, weatherFunction],
+        llm: model,
+        prompt,
+        enforceSingleFunctionUsage: false,
+        outputParser,
+    });
+    const response = await runnable.invoke({
+        question: "What's the weather like in Berkeley CA?",
+    });
+    console.log(response);
+    expect("state" in response).toBe(true);
+    expect("city" in response).toBe(true);
+});

package/dist/chains/openai_functions/tests/extraction.int.test.d.ts

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

package/dist/chains/openai_functions/tests/extraction.int.test.js

@@ -0,0 +1,33 @@
+import { test, expect } from "@jest/globals";
+import { z } from "zod";
+import { ChatOpenAI } from "@langchain/openai";
+import { createExtractionChainFromZod } from "../extraction.js";
+test("extraction chain", async () => {
+    const chain = createExtractionChainFromZod(z.object({
+        "person-name": z.string().optional(),
+        "person-age": z.number().optional(),
+        "person-hair_color": z.string().optional(),
+        "dog-name": z.string().optional(),
+        "dog-breed": z.string().optional(),
+    }), new ChatOpenAI({ modelName: "gpt-3.5-turbo-0613", temperature: 0 }));
+    const result = await chain.run(`Alex is 5 feet tall. Claudia is 4 feet taller Alex and jumps higher than him. Claudia is a brunette and Alex is blonde.
+    Alex's dog Frosty is a labrador and likes to play hide and seek.`);
+    expect(result).toMatchInlineSnapshot(`
+    [
+      {
+        "dog-breed": "labrador",
+        "dog-name": "Frosty",
+        "person-age": 0,
+        "person-hair_color": "blonde",
+        "person-name": "Alex",
+      },
+      {
+        "dog-breed": "",
+        "dog-name": "",
+        "person-age": 0,
+        "person-hair_color": "brunette",
+        "person-name": "Claudia",
+      },
+    ]
+  `);
+});

package/dist/chains/openai_functions/tests/openapi.int.test.d.ts

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

package/dist/chains/openai_functions/tests/openapi.int.test.js

@@ -0,0 +1,130 @@
+import { test } from "@jest/globals";
+import { ChatOpenAI } from "@langchain/openai";
+import { createOpenAPIChain } from "../openapi.js";
+test("OpenAPI chain with a provided full spec", async () => {
+    const chain = await createOpenAPIChain({
+        openapi: "3.0.1",
+        info: { version: "v0", title: "Open AI Klarna product Api" },
+        servers: [{ url: "https://www.klarna.com/us/shopping" }],
+        tags: [
+            {
+                name: "open-ai-product-endpoint",
+                description: "Open AI Product Endpoint. Query for products.",
+            },
+        ],
+        paths: {
+            "/public/openai/v0/products": {
+                get: {
+                    tags: ["open-ai-product-endpoint"],
+                    summary: "API for fetching Klarna product information",
+                    operationId: "productsUsingGET",
+                    parameters: [
+                        {
+                            name: "countryCode",
+                            in: "query",
+                            description: "ISO 3166 country code with 2 characters based on the user location. Currently, only US, GB, DE, SE and DK are supported.",
+                            required: true,
+                            schema: { type: "string" },
+                        },
+                        {
+                            name: "q",
+                            in: "query",
+                            description: "A precise query that matches one very small category or product that needs to be searched for to find the products the user is looking for. If the user explicitly stated what they want, use that as a query. The query is as specific as possible to the product name or category mentioned by the user in its singular form, and don't contain any clarifiers like latest, newest, cheapest, budget, premium, expensive or similar. The query is always taken from the latest topic, if there is a new topic a new query is started. If the user speaks another language than English, translate their request into English (example: translate fia med knuff to ludo board game)!",
+                            required: true,
+                            schema: { type: "string" },
+                        },
+                        {
+                            name: "size",
+                            in: "query",
+                            description: "number of products returned",
+                            required: false,
+                            schema: { type: "integer" },
+                        },
+                        {
+                            name: "min_price",
+                            in: "query",
+                            description: "(Optional) Minimum price in local currency for the product searched for. Either explicitly stated by the user or implicitly inferred from a combination of the user's request and the kind of product searched for.",
+                            required: false,
+                            schema: { type: "integer" },
+                        },
+                        {
+                            name: "max_price",
+                            in: "query",
+                            description: "(Optional) Maximum price in local currency for the product searched for. Either explicitly stated by the user or implicitly inferred from a combination of the user's request and the kind of product searched for.",
+                            required: false,
+                            schema: { type: "integer" },
+                        },
+                    ],
+                    responses: {
+                        "200": {
+                            description: "Products found",
+                            content: {
+                                "application/json": {
+                                    schema: { $ref: "#/components/schemas/ProductResponse" },
+                                },
+                            },
+                        },
+                        "503": { description: "one or more services are unavailable" },
+                    },
+                    deprecated: false,
+                },
+            },
+        },
+        components: {
+            schemas: {
+                Product: {
+                    type: "object",
+                    properties: {
+                        attributes: { type: "array", items: { type: "string" } },
+                        name: { type: "string" },
+                        price: { type: "string" },
+                        url: { type: "string" },
+                    },
+                    title: "Product",
+                },
+                ProductResponse: {
+                    type: "object",
+                    properties: {
+                        products: {
+                            type: "array",
+                            items: { $ref: "#/components/schemas/Product" },
+                        },
+                    },
+                    title: "ProductResponse",
+                },
+            },
+        },
+    }, { llm: new ChatOpenAI({ modelName: "gpt-4-0613", temperature: 0 }) });
+    const result = await chain.run(`What are some options for a men's large blue button down shirt`);
+    console.log(result);
+});
+test("OpenAPI chain with yml spec from a URL", async () => {
+    const chain = await createOpenAPIChain("https://gist.githubusercontent.com/roaldnefs/053e505b2b7a807290908fe9aa3e1f00/raw/0a212622ebfef501163f91e23803552411ed00e4/openapi.yaml", {
+        llm: new ChatOpenAI({ modelName: "gpt-4-0613", temperature: 0 }),
+    });
+    const result = await chain.run(`What's today's comic?`);
+    console.log(result);
+});
+test("OpenAPI chain with yml spec from a URL with a path parameter", async () => {
+    const chain = await createOpenAPIChain("https://gist.githubusercontent.com/roaldnefs/053e505b2b7a807290908fe9aa3e1f00/raw/0a212622ebfef501163f91e23803552411ed00e4/openapi.yaml", {
+        llm: new ChatOpenAI({ modelName: "gpt-4-0613", temperature: 0 }),
+    });
+    const result = await chain.run(`What comic has id 2184?`);
+    console.log(result);
+});
+test("OpenAPI chain with yml spec from a URL requiring a POST request", async () => {
+    const chain = await createOpenAPIChain("https://api.speak.com/openapi.yaml", {
+        llm: new ChatOpenAI({ modelName: "gpt-4-0613", temperature: 0 }),
+    });
+    const result = await chain.run(`How would you say no thanks in Russian?`);
+    console.log(result);
+});
+test("OpenAPI chain with a longer spec and tricky query required params", async () => {
+    const chain = await createOpenAPIChain("https://scholar-ai.net/openapi.yaml", {
+        params: {
+            sort: "cited_by_count",
+        },
+    });
+    const result = await chain.run("Can you find and explain some articles about the intersection of AI and VR?");
+    console.log(result);
+});

package/dist/chains/openai_functions/tests/openapi.test.d.ts

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