Alpha Notice: These docs cover the v1-alpha release. Content is incomplete and subject to change.For the latest stable version, see the v0 LangChain Python or LangChain JavaScript docs.
1.0 Alpha releases are available for the following packages:
  • langchain
  • @langchain/core
  • @langchain/anthropic
  • @langchain/openai
Broader support will be rolled out during the alpha period.

​
New features

​
Core exports from langchain

The langchain package now exports key primitives like tool, message types, ToolNode, createAgent, and more directly from the root package. 
import { tool, HumanMessage, createAgent } from "langchain";

​
createAgent in core langchain

The React-style agent is now part of the core langchain project. Import directly from langchain: 
import { createAgent, HumanMessage, tool } from "langchain";
import { z } from "zod";

const getWeather = tool(async ({ city }) => `Sunny in ${city}`, {
  name: "getWeather",
  description: "Get current weather by city",
  schema: z.object({ city: z.string() }),
});

const agent = await createAgent({
  // New: pass a model by name
  model: "openai:gpt-4o-mini",
  tools: [getWeather],
  responseFormat: z.object({ answer: z.string() }),
});

const res = await agent.invoke({
  messages: [new HumanMessage("Weather in SF?")],
});
console.log(res.structuredResponse.answer);
You can now pass a “model as string” option to define the model to use. This requires you to have the specific model provider package installed (e.g. @langchain/openai for openai:gpt-4o-mini).

​
ToolNode exported from langchain

Build agent graphs that execute tools as a node. This makes tool execution composable within graph workflows. 
import { StateGraph } from "@langchain/langgraph";
import { ToolNode, tool } from "langchain";

const tools = [tool(async ({ query }) => `Results for: ${query}`, {
  name: "search", schema: z.object({ query: z.string() })
})];

const graph = new StateGraph({ channels: { messages: [] } })
  .addNode("tools", new ToolNode(tools))
  .addEdge("__start__", "tools");

const result = await graph.compile().invoke({
  messages: [/* tool call messages */]
});

​
Default tool-error handling in agents

When handleToolErrors is true (default), tool exceptions are caught and converted into a ToolMessage so the agent can recover. Set it to false to surface raw errors for strict workflows. 
import { ToolNode, ToolMessage, tool } from "langchain";

const tools = [
  tool(/* ... */),
  // ...
];

// default: handleToolErrors: true → returns a ToolMessage with error text
const forgiving = new ToolNode(tools);

// strict: throw on tool error
const strict = new ToolNode(tools, { handleToolErrors: false });

// dynamic: custom error handling
const dynamic = new ToolNode(tools, {
  handleToolErrors: (error, toolCall) => {
    if (error instanceof Error && error.message.includes("Fetch Failed")) {
      return new ToolMessage({
        content: "Fetch Failed. Please try again.",
        tool_call_id: toolCall.id!,
      });
    }

    throw error;
  },
});

​
Standard typed message content

@langchain/core features standard, typed message content. This includes standard types for reasoning, citations, server-side tool calls, and other modern LLM features. There are no breaking changes associated with existing message content. The standard content can be lazily-parsed off of existing v0 messages using the contentBlocks property: 
import { AIMessage } from "@langchain/core";

new AIMessage("Hello, world").contentBlocks

​
Breaking changes

​
Migration guide

Follow these steps to migrate your JavaScript/TypeScript code to LangChain v1.0:

​
1. Node version

Set engines.node to >=20 and update CI runners: 
// package.json
{ "engines": { "node": ">=20" } }

​
2. Import path updates

All langchain/schema/* exports removed: 
- import { PromptTemplate } from "langchain/schema/prompt_template";
+ import { PromptTemplate } from "langchain/prompts";

- import type { AttributeInfo } from "langchain/schema/query_constructor";
+ import type { AttributeInfo } from "langchain/chains/query_constructor";
Remove unsupported imports: 
- import { ... } from "langchain/runnables/remote";  // No longer exported
- import { ... } from "langchain/smith";             // Use separate langsmith package
- import { ... } from "langchain/callbacks";         // Use LCEL observability instead
- import { ... } from "langchain/agents";            // Use createAgent instead
Azure OpenAI package removed: 
- import { AzureChatOpenAI } from "@langchain/azure-openai";
+ import { AzureChatOpenAI } from "@langchain/openai";
// Configure with Azure endpoints in ChatOpenAI constructor

​
3. Agent migration

Replace legacy agent imports with createAgent: 
- import { AgentExecutor, createOpenAIFunctionsAgent } from "langchain/agents";
- import { createReactAgent } from "@langchain/langgraph/prebuilt";
+ import { createAgent } from "langchain";
Migrate from legacy agent patterns: 
// Old pattern
- const agent = createOpenAIFunctionsAgent({ llm, tools, prompt });
- const agentExecutor = new AgentExecutor({ agent, tools });
- const result = await agentExecutor.invoke({ input: "Hello" });

// New pattern
+ const agent = createAgent({
+   model: "openai:gpt-4o-mini",
+   tools,
+   responseFormat: z.object({ answer: z.string() })
+ });
+ const result = await agent.invoke({
+   messages: [new HumanMessage("Hello")]
+ });
You can now pass model as a model name string to createAgent. This requires you to have the specific model provider package installed (e.g. @langchain/openai for openai:gpt-4o-mini). Use ToolNode to encapsulate tool execution in graphs: 
import { ToolNode } from "langchain";

const toolNode = new ToolNode([/* tools */]);

​
4. Error handling configuration

Decide on error policy for ToolNode: 
// Default: soft-handling (converts errors to ToolMessage)
const forgiving = new ToolNode([/* tools */], { handleToolErrors: true });

// Strict: throw on tool error
const strict = new ToolNode([/* tools */], { handleToolErrors: false });

​
Reporting issues

Please report any issues discovered with 1.0 on GitHub using the 'v1' label.

​
See also