How to use MCP with LangChain

1npm install @modelcontextprotocol/sdk langchain @langchain/core @langchain/openai zod
2npm install -D typescript @types/node

1// src/mcp-connection.ts
2import { Client } from "@modelcontextprotocol/sdk/client/index.js";
3import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
4
5export async function createMcpClient(
6  command: string,
7  args: string[],
8  env?: Record<string, string>
9): Promise<Client> {
10  const transport = new StdioClientTransport({
11    command,
12    args,
13    env: { ...process.env, ...env } as Record<string, string>,
14  });
15
16  const client = new Client(
17    { name: "langchain-mcp-bridge", version: "1.0.0" },
18    { capabilities: {} }
19  );
20
21  await client.connect(transport);
22  console.error(`Connected to MCP server: ${command} ${args.join(" ")}`);
23  return client;
24}

1// src/mcp-to-langchain.ts
2import { StructuredTool } from "@langchain/core/tools";
3import { z } from "zod";
4import { Client } from "@modelcontextprotocol/sdk/client/index.js";
5import { jsonSchemaToZod } from "./schema-converter.js";
6
7export async function mcpToolsToLangChain(client: Client): Promise<StructuredTool[]> {
8  const { tools } = await client.listTools();
9  
10  return tools.map(mcpTool => {
11    const zodSchema = jsonSchemaToZod(mcpTool.inputSchema);
12
13    return new McpLangChainTool({
14      name: mcpTool.name,
15      description: mcpTool.description || `MCP tool: ${mcpTool.name}`,
16      schema: zodSchema,
17      client,
18    });
19  });
20}
21
22class McpLangChainTool extends StructuredTool {
23  name: string;
24  description: string;
25  schema: z.ZodObject<any>;
26  private client: Client;
27
28  constructor(config: {
29    name: string;
30    description: string;
31    schema: z.ZodObject<any>;
32    client: Client;
33  }) {
34    super();
35    this.name = config.name;
36    this.description = config.description;
37    this.schema = config.schema;
38    this.client = config.client;
39  }
40
41  async _call(input: Record<string, unknown>): Promise<string> {
42    const result = await this.client.callTool({
43      name: this.name,
44      arguments: input,
45    });
46
47    const content = result.content as Array<{ type: string; text?: string }>;
48    return content
49      .filter(c => c.type === "text" && c.text)
50      .map(c => c.text)
51      .join("\n");
52  }
53}

1// src/schema-converter.ts
2import { z } from "zod";
3
4export function jsonSchemaToZod(schema: any): z.ZodObject<any> {
5  if (!schema || schema.type !== "object" || !schema.properties) {
6    return z.object({});
7  }
8
9  const shape: Record<string, z.ZodTypeAny> = {};
10  const required = new Set(schema.required || []);
11
12  for (const [key, prop] of Object.entries(schema.properties)) {
13    const p = prop as any;
14    let field: z.ZodTypeAny;
15
16    switch (p.type) {
17      case "string":
18        field = z.string();
19        break;
20      case "number":
21      case "integer":
22        field = z.number();
23        break;
24      case "boolean":
25        field = z.boolean();
26        break;
27      case "array":
28        field = z.array(z.any());
29        break;
30      default:
31        field = z.any();
32    }
33
34    if (p.description) field = field.describe(p.description);
35    if (!required.has(key)) field = field.optional();
36    if (p.default !== undefined) field = field.default(p.default);
37
38    shape[key] = field;
39  }
40
41  return z.object(shape);
42}

1// src/agent.ts
2import { ChatOpenAI } from "@langchain/openai";
3import { AgentExecutor, createOpenAIToolsAgent } from "langchain/agents";
4import { ChatPromptTemplate } from "@langchain/core/prompts";
5import { createMcpClient } from "./mcp-connection.js";
6import { mcpToolsToLangChain } from "./mcp-to-langchain.js";
7
8async function main() {
9  // Connect to MCP server
10  const mcpClient = await createMcpClient("node", ["path/to/mcp-server/dist/index.js"]);
11  const mcpTools = await mcpToolsToLangChain(mcpClient);
12  
13  console.error(`Loaded ${mcpTools.length} MCP tools: ${mcpTools.map(t => t.name).join(", ")}`);
14
15  // Create LLM and agent
16  const llm = new ChatOpenAI({ model: "gpt-4o", temperature: 0 });
17  
18  const prompt = ChatPromptTemplate.fromMessages([
19    ["system", "You are a helpful assistant with access to tools. Use them to answer questions accurately."],
20    ["human", "{input}"],
21    ["placeholder", "{agent_scratchpad}"],
22  ]);
23
24  const agent = await createOpenAIToolsAgent({ llm, tools: mcpTools, prompt });
25  const executor = new AgentExecutor({ agent, tools: mcpTools, verbose: true });
26
27  // Run the agent
28  const result = await executor.invoke({
29    input: "List all TypeScript files in the src directory",
30  });
31
32  console.log(result.output);
33
34  // Cleanup
35  await mcpClient.close();
36}
37
38main().catch(console.error);