docs/api_refs/typedoc.json

@@ -225,6 +225,7 @@
     "../../langchain-core/src/utils/async_caller.ts",
     "../../langchain-core/src/utils/chunk_array.ts",
     "../../langchain-core/src/utils/env.ts",
+    "../../langchain-core/src/utils/function_calling.ts",
     "../../langchain-core/src/utils/hash.ts",
     "../../langchain-core/src/utils/json_patch.ts",
     "../../langchain-core/src/utils/json_schema.ts",
@@ -235,6 +236,7 @@
     "../../langchain-core/src/utils/types.ts",
     "../../langchain-core/src/vectorstores.ts",
     "../../libs/langchain-anthropic/src/index.ts",
+    "../../libs/langchain-cloudflare/src/index.ts",
     "../../libs/langchain-cohere/src/index.ts",
     "../../libs/langchain-community/src/load/index.ts",
     "../../libs/langchain-community/src/load/serializable.ts",

docs/core_docs/docs/expression_language/interface.mdx

@@ -68,8 +68,8 @@ import BatchExample from "@examples/guides/expression_language/interface_batch.t
 
 <CodeBlock language="typescript">{BatchExample}</CodeBlock>
 
-You can also pass a `batchOptions` argument to the call. There are options to set maximum concurrency
-and whether or not to return exceptions instead of throwing them (useful for gracefully handling failures!):
+You can also pass additional arguments to the call. The standard LCEL config object contains an option to set maximum concurrency,
+and an additional `batch()` specific config object that includes an option for whether or not to return exceptions instead of throwing them (useful for gracefully handling failures!):
 
 import BatchExampleWithOptions from "@examples/guides/expression_language/interface_batch_with_options.ts";
 
@@ -84,8 +84,15 @@ You can stream all steps (default) or include/exclude steps by name, tags or met
 
 This method yields [JSONPatch](https://jsonpatch.com/) ops that when applied in the same order as received build up the RunState.
 
+To reconstruct the JSONPatches into a single JSON object you can use the [`applyPatch`](https://api.js.langchain.com/functions/langchain_core_utils_json_patch.applyPatch.html) method.
+The example below demonstrates how to pass the patch to the `applyPatch` method.
+
 Here's an example with streaming intermediate documents from a retrieval chain:
 
 import StreamLogExample from "@examples/guides/expression_language/interface_stream_log.ts";
 
+```bash npm2yarn
+npm install @langchain/community @langchain/openai
+```
+
 <CodeBlock language="typescript">{StreamLogExample}</CodeBlock>

docs/core_docs/docs/integrations/vectorstores/turbopuffer.mdx

@@ -0,0 +1,24 @@
+# Turbopuffer
+
+## Setup
+
+First you must sign up for a Turbopuffer account [here](https://turbopuffer.com/join).
+Then, once you have an account you can create an API key.
+
+Set your API key as an environment variable:
+
+```bash
+export TURBOPUFFER_API_KEY=<YOUR_API_KEY>
+```
+
+## Usage
+
+import CodeBlock from "@theme/CodeBlock";
+import SimilaritySearchExample from "@examples/indexes/vector_stores/turbopuffer.ts";
+
+Here are some examples of how to use the class. You can filter your queries by previous specified metadata, but
+keep in mind that currently only string values are supported.
+
+See [here for more information](https://turbopuffer.com/docs/reference/query#filter-parameters) on acceptable filter formats.
+
+<CodeBlock language="typescript">{SimilaritySearchExample}</CodeBlock>

docs/core_docs/docs/modules/agents/how_to/agent_structured.mdx

@@ -26,7 +26,7 @@ import { RunnableSequence } from "langchain/runnables";
 import { ChatPromptTemplate, MessagesPlaceholder } from "langchain/prompts";
 import { ChatOpenAI } from "@langchain/openai";
 import { AgentExecutor } from "langchain/agents";
-import { DynamicTool } from "langchain/tools";
+import { DynamicTool } from "@langchain/core/tools";
 import type { FunctionsAgentAction } from "langchain/agents/openai/output_parser";
 import { convertToOpenAIFunction } from "@langchain/core/utils/function_calling";
 

docs/core_docs/docs/modules/agents/how_to/custom_agent.mdx

@@ -34,7 +34,7 @@ Next, let's define some tools to use.
 Let's write a really simple JavaScript function to calculate the length of a word that is passed in.
 
 ```ts
-import { DynamicTool } from "langchain/tools";
+import { DynamicTool } from "@langchain/core/tools";
 
 const customTool = new DynamicTool({
   name: "get_word_length",

docs/core_docs/docs/use_cases/tool_use/agents.mdx

@@ -0,0 +1,166 @@
+---
+sidebar_position: 2
+---
+
+# Agents
+
+Chains are great when we know the specific sequence of tool usage needed for any user input. But for certain use cases, how many times we use tools depends on the input.
+In these cases, we want to let the model itself decide how many times to use tools and in what order. That's where [Agents](/docs/modules/agents/) come in!
+
+LangChain comes with a number of built-in agents that are optimized for different use cases. Read about [all the available agent types](/docs/modules/agents/agent_types/) here.
+
+For this example, let’s try out the OpenAI tools agent, which makes use of the new OpenAI tool-calling API (this is only available in the latest OpenAI models,
+and differs from function-calling in that the model can return multiple function invocations at once).
+
+Keep in mind that some agents only support single-argument tools - for these agents, you will need to use a `DynamicTool` instead
+and parse the input string yourself.
+
+## Setup
+
+Because we're using OpenAI for this guide, we'll need to install its partner package:
+
+import IntegrationInstallTooltip from "@mdx_components/integration_install_tooltip.mdx";
+
+<IntegrationInstallTooltip></IntegrationInstallTooltip>
+
+```bash npm2yarn
+npm install @langchain/openai
+```
+
+You'll need to sign up for an OpenAI key and set it as an environment variable named `OPENAI_API_KEY`.
+
+We'll also use the popular validation library [Zod](https://zod.dev) to define our tool schemas. It's already
+a dependency of `langchain`, but you can install it explicitly like this too:
+
+```bash npm2yarn
+npm install zod
+```
+
+## Create tools
+
+First, we need to create some tool to call. For this example, we will create custom tools from functions.
+For more information on creating custom tools, please [see this guide](/docs/modules/agents/tools/).
+
+```ts
+import { z } from "zod";
+import { DynamicStructuredTool } from "@langchain/core/tools";
+
+const addTool = new DynamicStructuredTool({
+  name: "add",
+  description: "Add two integers together.",
+  schema: z.object({
+    firstInt: z.number(),
+    secondInt: z.number(),
+  }),
+  func: async ({ firstInt, secondInt }) => {
+    return (firstInt + secondInt).toString();
+  },
+});
+
+const multiplyTool = new DynamicStructuredTool({
+  name: "multiply",
+  description: "Multiply two integers together.",
+  schema: z.object({
+    firstInt: z.number(),
+    secondInt: z.number(),
+  }),
+  func: async ({ firstInt, secondInt }) => {
+    return (firstInt * secondInt).toString();
+  },
+});
+
+const exponentiateTool = new DynamicStructuredTool({
+  name: "exponentiate",
+  description: "Exponentiate the base to the exponent power.",
+  schema: z.object({
+    base: z.number(),
+    exponent: z.number(),
+  }),
+  func: async ({ base, exponent }) => {
+    return (base ** exponent).toString();
+  },
+});
+
+const tools = [addTool, multiplyTool, exponentiateTool];
+```
+
+## Create prompt
+
+```ts
+import { pull } from "langchain/hub";
+import type { ChatPromptTemplate } from "@langchain/core/prompts";
+
+// Get the prompt to use - you can modify this!
+// You can also see the full prompt at:
+// https://smith.langchain.com/hub/hwchase17/openai-tools-agent
+const prompt = await pull<ChatPromptTemplate>("hwchase17/openai-tools-agent");
+```
+
+## Create agent
+
+```ts
+import { ChatOpenAI } from "@langchain/openai";
+import { AgentExecutor, createOpenAIToolsAgent } from "langchain/agents";
+
+const model = new ChatOpenAI({
+  modelName: "gpt-3.5-turbo-1106",
+  temperature: 0,
+});
+
+const agent = await createOpenAIToolsAgent({
+  llm: model,
+  tools,
+  prompt,
+});
+
+const agentExecutor = new AgentExecutor({
+  agent,
+  tools,
+  verbose: true,
+});
+```
+
+## Invoke agent
+
+:::info
+You can see a LangSmith trace of this example [here](https://smith.langchain.com/public/fc11cacc-f467-4c39-a46e-8bfefa37b1f9/r)
+:::
+
+```ts
+await agentExecutor.invoke({
+  input:
+    "Take 3 to the fifth power and multiply that by the sum of twelve and three, then square the whole result",
+});
+```
+
+```
+> Entering new AgentExecutor chain...
+
+Invoking: `exponentiate` with `{'base': 3, 'exponent': 5}`
+
+
+243
+Invoking: `add` with `{'first_int': 12, 'second_int': 3}`
+
+
+15
+Invoking: `multiply` with `{'first_int': 243, 'second_int': 15}`
+
+
+3645
+Invoking: `exponentiate` with `{'base': 3645, 'exponent': 2}`
+
+
+13286025
+
+The result of taking 3 to the fifth power and multiplying that by the sum of twelve and three, then squaring the whole result is 13,286,025.
+
+> Finished chain.
+```
+
+```
+{
+  input: 'Take 3 to the fifth power and multiply that by the sum of twelve and three, then square the whole result',
+  output: 'The result of taking 3 to the fifth power and multiplying that by the sum of twelve and three, then squaring the whole result is 13,286,025.'
+}
+```

docs/core_docs/docs/use_cases/tool_use/index.mdx

@@ -0,0 +1,15 @@
+---
+sidebar_position: 2
+---
+
+# Tool use
+
+An exciting use case for LLMs is building natural language interfaces for other "tools", whether those are APIs, functions, databases, etc. LangChain is great for building such interfaces because it has:
+
+- Good model output parsing, which makes it easy to extract JSON, XML, OpenAI function-calls, etc. from model outputs.
+- A large collection of built-in [Tools](/docs/integrations/tools).
+- Provides a lot of flexibility in how you call these tools.
+
+There are two main ways to use tools: [chains](/docs/modules/chains) and [agents](/docs/modules/agents/). Chains lets you create a pre-defined sequence of tool usage(s). Agents let the model use tools in a loop, so that it can decide how many times to use tools.
+
+To get started with both approaches, head to the [Quickstart](/docs/use_cases/tool_use/quickstart) page.