Discuss createAgent() function in langchain with all the parameters passed to it. Use TypeScript SDK context.

Question

Accepted Answer

The `createAgent()` function in LangChain (JavaScript/TypeScript SDK) is the primary entry point for building intelligent agents. It combines a language model with a set of tools and executes them in a loop until the model determines it has a final answer . The agent works by repeatedly calling the LLM with the current conversation history; if the LLM decides to call a tool, the agent executes it, adds the result to the conversation, and loops back to the LLM until a stopping condition is met . import { createAgent, tool } from "langchain";
import { ChatOpenAI } from "@langchain/openai";
import { z } from "zod";

const weatherTool = tool(
  async ({ location }) => {
    return `The weather in ${location} is sunny and 22°C.`;
  },
  {
    name: "get_weather",
    description: "Get the current weather for a location.",
    schema: z.object({
      location: z.string().describe("The city name to get weather for"),
    }),
  }
);

const agent = createAgent({
  model: new ChatOpenAI({ model: "gpt-4o", temperature: 0 }),
  tools: [weatherTool],
  systemPrompt: "You are a helpful assistant that knows the weather.",
});

const result = await agent.invoke({
  messages: [{ role: "user", content: "What's the weather in Paris?" }],
});

console.log(result.messages[result.messages.length - 1].content); `model`: The language model to drive the agent. Can be a string identifier like `"anthropic:claude-sonnet-4-5-20250929"` or an instance of a chat model like `new ChatOpenAI()` . This parameter is required. `tools`: An array of tools the agent can use. Tools are defined using the `tool()` helper function, which requires `name`, `description`, and a `schema` (Zod object for TypeScript) . If omitted or empty, the agent will be a simple conversational agent without tool-calling ability . `systemPrompt`: A string or `SystemMessage` that sets the system prompt for the agent. This provides high-level instructions that guide the agent's behavior throughout the conversation . `responseFormat`: An optional configuration for structured responses. Accepts a `ToolStrategy`, `ProviderStrategy`, or a Pydantic/Zod model class. When provided, the agent will handle structured output during the conversation flow . `middleware`: A sequence of `AgentMiddleware` instances that intercept and modify agent behavior at various lifecycle stages. Middleware can hook into: `before_agent` (runs once on invocation, good for loading memory), `before_model` (fires before each model call, ideal for trimming history or PII detection), `wrap_model_call` (wraps the entire model call for caching, retries), `wrap_tool_call` (wraps tool execution for validation or enrichment), `after_model` (runs after model response, natural for human-in-the-loop), and `after_agent` (runs on completion for cleanup) . import { createAgent, createMiddleware, summarizationMiddleware } from "langchain";

// Using built-in middleware
const agent = createAgent({
  model: "anthropic:claude-sonnet-4-5-20250929",
  tools: TOOLS,
  systemPrompt: "You are a helpful assistant.",
  middleware: [
    summarizationMiddleware({
      model: "anthropic:claude-sonnet-4-5-20250929",
      trigger: { tokens: 4000 },
    }),
    createMiddleware({
      name: "customMiddleware",
      beforeModel: (state) => {
        console.log("Before model call, messages:", state.messages.length);
        return state;
      },
    }),
  ],
}); `stateSchema`: An optional Zod object or `StateSchema` extending `AgentState`. This defines typed state fields that are persisted between multiple invocations. Can include reducers and special handling through LangGraph's state management . `contextSchema`: A Zod object defining the shape of runtime context passed to each invocation. Context is read-only, not persisted between calls, and ideal for passing user IDs, permissions, or tenant data . `checkpointer`: A `BaseCheckpointSaver` instance (or `true`) that enables conversation persistence. Used for saving graph state for a single thread (single conversation) . `store`: A `BaseStore` instance for persisting data across multiple threads (multiple conversations/users). Different from checkpointer, which is conversation-specific . import { createAgent, tool } from "langchain";
import { z } from "zod";

const getUserName = tool(
  async (_, config) => {
    return `User's name is ${config.context.user_name}`;
  },
  {
    name: "get_user_name",
    description: "Return the current user's name from context.",
    schema: z.object({}),
  }
);

const agent = createAgent({
  model: "openai:gpt-4o-mini",
  tools: [getUserName],
  contextSchema: z.object({
    user_name: z.string(),
  }),
});

const result = await agent.invoke(
  {
    messages: [{ role: "user", content: "What is my name?" }],
  },
  {
    context: { user_name: "Alice" },
  }
); `version`: Determines graph version for tool execution. `"v1"` processes all tool calls concurrently via `Promise.all` inside a single node. `"v2"` dispatches each tool call as an indep

Discuss createAgent() function in langchain with all the parameters passed to it. Use TypeScript SDK context.

The `createAgent()` function in LangChain is a factory that creates a ReAct agent by connecting an LLM with tools, middleware, and various configuration options for state management, structured outputs, and execution control.

Discuss createAgent() function in langchain with all the parameters passed to it. Use TypeScript SDK context.

The `createAgent()` function in LangChain is a factory that creates a ReAct agent by connecting an LLM with tools, middleware, and various configuration options for state management, structured outputs, and execution control.

Scenario Questions

Follow-up Questions

Discuss createAgent() function in langchain with all the parameters passed to it. Use TypeScript SDK context.

The createAgent() function in LangChain is a factory that creates a ReAct agent by connecting an LLM with tools, middleware, and various configuration options for state management, structured outputs, and execution control.

Discuss createAgent() function in langchain with all the parameters passed to it. Use TypeScript SDK context.

The createAgent() function in LangChain is a factory that creates a ReAct agent by connecting an LLM with tools, middleware, and various configuration options for state management, structured outputs, and execution control.

Scenario Questions

Follow-up Questions

The `createAgent()` function in LangChain is a factory that creates a ReAct agent by connecting an LLM with tools, middleware, and various configuration options for state management, structured outputs, and execution control.

The `createAgent()` function in LangChain is a factory that creates a ReAct agent by connecting an LLM with tools, middleware, and various configuration options for state management, structured outputs, and execution control.