How do you pass runtime context (userId, authToken, DB connection) into a Tool using RunnableConfig?

Question

Accepted Answer

LangChain's `RunnableConfig` provides a clean, dependency-injection style way to pass contextual information through your agent's execution chain. By configuring a `contextSchema` on your agent, you define the shape of the runtime data you expect. This context is then automatically made available in the second argument of any tool's function, allowing the tool to access user-specific information like `userId`, authentication tokens, or database connections without the LLM needing to know about them or the user having to provide them. This keeps your tool's input schema focused on what the LLM should generate (e.g., `query` or `productId`), while sensitive or operational context is injected separately. Define a Zod object that specifies the shape and types of the context your tools will need. This can include `userId`, `authToken`, `tenantId`, or even a database connection pool. This schema ensures type safety throughout your application. import { z } from "zod";

const contextSchema = z.object({
  userId: z.string().describe("The ID of the authenticated user"),
  authToken: z.string().describe("JWT or API key for external service authentication"),
  tenantId: z.string().optional().describe("Multi-tenant identifier"),
});

type ContextType = z.infer<typeof contextSchema>; When defining your tool, the async function receives `config` as its second parameter. The `config.configurable` object contains the merged context. You can then use the `userId`, `authToken`, or any other context value inside your tool's logic. import { tool } from "@langchain/core/tools";

export const fetchUserOrdersTool = tool(
  async ({ status }, config) => {
    // Extract context from config.configurable
    const context = config?.configurable as ContextType;
    
    if (!context?.userId) {
      return JSON.stringify({
        status: "error",
        message: "No user ID provided in context.",
      });
    }
    
    // Use the auth token from context to call an external API
    const response = await fetch(`https://api.example.com/users/${context.userId}/orders`, {
      headers: {
        'Authorization': `Bearer ${context.authToken}`,
        'X-Tenant-ID': context.tenantId || 'default',
      },
    });
    
    if (!response.ok) {
      return JSON.stringify({
        status: "error",
        message: `API request failed: ${response.status}`,
      });
    }
    
    const data = await response.json();
    return JSON.stringify({ status: "success", orders: data });
  },
  {
    name: "fetch_user_orders",
    description: "Fetches the current user's order history.",
    schema: z.object({
      status: z.enum(["pending", "shipped", "delivered"])
        .optional()
        .describe("Filter orders by status"),
    }),
  }
); When you invoke your agent, you pass the runtime context as a property of the `configurable` object. This context is then propagated down to the tools. const result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "Show me my recent orders." },
    ],
  },
  {
    configurable: {
      userId: "user-123",
      authToken: "Bearer eyJhbGc...",
      tenantId: "acme-corp",
    },
  }
); For more complex scenarios where you need to pass a database connection pool or other non-serializable resources, you should instantiate these as singletons or request-scoped objects and store them directly in the `configurable` object. If you're using the `createAgent` factory, you can enforce the context schema by passing it to the `contextSchema` parameter. This ensures that all tools receive the correctly typed context and will cause a type error if you forget to provide required fields. import { createAgent } from "langchain";
import { z } from "zod";

const agent = createAgent({
  model: "openai:gpt-4o",
  tools: [fetchUserOrdersTool],
  contextSchema: z.object({
    userId: z.string(),
    authToken: z.string(),
    tenantId: z.string().optional(),
  }),
}); A significant benefit of this pattern is testability. You can easily unit-test your tools by passing a mock context directly to their invoke method, without needing to spin up a full agent or mock network requests if you design your tool to use dependency injection. import { fetchUserOrdersTool } from "./tools";

const mockContext = {
  configurable: {
    userId: "test-user-123",
    authToken: "mock-token",
  },
};

const result = await fetchUserOrdersTool.invoke(
  { status: "delivered" },
  mockContext
);

// Now you can assert on the result structure This pattern is a clean application of dependency injection for LangChain tools. It separates the concerns of `what the LLM decides` (the input arguments) from `what the application provides` (the runtime context). This makes your tools more reusable, testable, and secure, as sensitive information like auth tokens never need to be generated by the LLM or passed through the prompt.

How do you pass runtime context (userId, authToken, DB connection) into a Tool using RunnableConfig?

You pass runtime context into a Tool by leveraging the `context` parameter in `RunnableConfig`, which propagates through the entire call chain, allowing tools to access values like `userId`, `authToken`, or `tenantId` without coupling them to the tool's input schema.

How do you pass runtime context (userId, authToken, DB connection) into a Tool using RunnableConfig?

You pass runtime context into a Tool by leveraging the `context` parameter in `RunnableConfig`, which propagates through the entire call chain, allowing tools to access values like `userId`, `authToken`, or `tenantId` without coupling them to the tool's input schema.

Scenario Questions

Follow-up Questions

How do you pass runtime context (userId, authToken, DB connection) into a Tool using RunnableConfig?

You pass runtime context into a Tool by leveraging the context parameter in RunnableConfig, which propagates through the entire call chain, allowing tools to access values like userId, authToken, or tenantId without coupling them to the tool's input schema.

How do you pass runtime context (userId, authToken, DB connection) into a Tool using RunnableConfig?

You pass runtime context into a Tool by leveraging the context parameter in RunnableConfig, which propagates through the entire call chain, allowing tools to access values like userId, authToken, or tenantId without coupling them to the tool's input schema.

Scenario Questions

Follow-up Questions

You pass runtime context into a Tool by leveraging the `context` parameter in `RunnableConfig`, which propagates through the entire call chain, allowing tools to access values like `userId`, `authToken`, or `tenantId` without coupling them to the tool's input schema.

You pass runtime context into a Tool by leveraging the `context` parameter in `RunnableConfig`, which propagates through the entire call chain, allowing tools to access values like `userId`, `authToken`, or `tenantId` without coupling them to the tool's input schema.