Use Pathbound with LangChain and LangGraph.

Your application knows how to run an agent. Pathbound gives that agent the customer evidence it cannot find in the model or application state: the resolved contact, company, conversations, and recent activity behind the request.

Start free → See the setup

What you get

Customer context, inside LangChain & LangGraph.

The official LangChain MCP adapters turn Pathbound’s remote tools into regular LangChain tools. Load them once when the application starts, then pass the resulting tool list to a LangChain agent or LangGraph tool node.

One remote HTTP server for customer profiles, companies, events, timelines, conversations, and server-side aggregation.
The same tool objects in LangChain and LangGraph, so moving from a prebuilt agent to an explicit graph does not require another Pathbound integration.
Python and TypeScript adapters maintained in the LangChain projects, with static bearer headers for a deployed or headless application.
Model choice stays in your application. Pathbound supplies customer context and does not call the model on your behalf.

Connect

Connect LangChain & LangGraph in about five minutes.

Create a scoped Pathbound API key, keep it in the application environment, and register Pathbound as a remote HTTP MCP server. The examples load the resulting tools into a standard LangChain agent; the same tools can be passed to a LangGraph ToolNode.

Python — LangChain and LangGraph

Bearer API key

Install langchain-mcp-adapters alongside the LangChain or LangGraph packages already used by the application.
Create a Pathbound REST API key with only the scopes this agent needs and store it as PATHBOUND_API_KEY. Do not commit the key.
Configure MultiServerMCPClient with the Pathbound endpoint, HTTP transport, and an Authorization bearer header.
Call get_tools(), then pass the returned tools to create_agent or a LangGraph ToolNode. Start with read tools before enabling any write path.

Python

import os
from langchain.agents import create_agent
from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({
    "pathbound": {
        "transport": "http",
        "url": "https://mcp.pathbound.ai/mcp",
        "headers": {
            "Authorization": f"Bearer {os.environ['PATHBOUND_API_KEY']}"
        },
    }
})

tools = await client.get_tools()
agent = create_agent("openai:gpt-5.5", tools)

TypeScript — LangChain.js and LangGraph.js

Bearer API key

Install @langchain/mcp-adapters alongside the application’s LangChain packages.
Store a scoped Pathbound REST API key as PATHBOUND_API_KEY in the runtime environment.
Add Pathbound under mcpServers with HTTP transport and an Authorization bearer header.
Call getTools() and pass the result to createAgent or the LangGraph.js tool node used by the application.

TypeScript

import { createAgent } from "langchain";
import { MultiServerMCPClient } from "@langchain/mcp-adapters";

const client = new MultiServerMCPClient({
  mcpServers: {
    pathbound: {
      transport: "http",
      url: "https://mcp.pathbound.ai/mcp",
      headers: {
        Authorization: `Bearer ${process.env.PATHBOUND_API_KEY}`,
      },
    },
  },
  useStandardContentBlocks: true,
});

const tools = await client.getTools();
const agent = createAgent({ model: "openai:gpt-5.5", tools });

First prompts

What LangChain & LangGraph can do with your data.

Once connected, these are real jobs LangChain & LangGraph runs against your customer data. Each recipe is one tested prompt—paste it and go.

Try this prompt in LangChain & LangGraph

Research every trial signup from the last 24 hours. For each one, pull their profile and company details, read what they did on our site and in the product, and work out who they are and whether the account is a fit. Write a short research brief as a note on each contact (who they are, what they did, verdict, suggested opener), then give me the list ranked by how promising they look, with one line each on why.

See the full recipe—Trial-signup research

More jobs in use cases, each with a tested prompt.

Adapters, credentials, and production use.

Does LangGraph need a separate Pathbound integration?

No. The LangChain MCP adapters return standard LangChain tools. Pass the same tools to a prebuilt agent or to a LangGraph ToolNode. The connection URL and credential do not change.

Should the application use OAuth or an API key?

A server process normally uses a scoped Pathbound REST API key stored in its environment. Use an interactive OAuth implementation only when each end user should connect their own Pathbound identity and permissions. Do not share one workspace key across external tenants unless that access model is intentional.

Can I deploy the agent with LangSmith?

Yes. Keep PATHBOUND_API_KEY in the deployment environment and initialize the MCP client in the graph or application code. LangSmith Deployment changes where the application runs; it does not require a different Pathbound endpoint.

Why does each Pathbound tool call open a fresh MCP session?

The LangChain multi-server clients are stateless by default. That works for Pathbound because customer state lives behind the server rather than in the MCP session. Use explicit session management only when another server or workflow requires it.

Should every Pathbound tool be available to the model?

Not necessarily. Start with the read tools needed for the job and filter the loaded list before binding it to the model. Add write tools only when the workflow requires them and place approval or policy checks around the corresponding tool node.

Can I use any model provider?

Yes. The MCP adapter produces LangChain tools independently of the model. Use the OpenAI, Anthropic, Google, or other LangChain model integration already selected by the application.