LangChain.jsとは？ AIエージェント開発の定番フレームワークを活用例とコードで解説

npm install langchain @langchain/core zod

# OpenAIを使う場合
npm install @langchain/openai
 
# Anthropic（Claude）を使う場合
npm install @langchain/anthropic
 
# Google（Gemini）を使う場合
npm install @langchain/google-genai

# 使うプロバイダーのAPIキーを設定
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."

import { createAgent, tool } from "langchain";
import * as z from "zod";
 
// ツールを定義
const getWeather = tool(
  ({ city }) => `${city}の天気は晴れ、気温25℃です。`,
  {
    name: "get_weather",
    description: "指定された都市の天気を取得する",
    schema: z.object({
      city: z.string().describe("天気を取得する都市名"),
    }),
  }
);
 
// エージェントを作成
const agent = createAgent({
  model: "claude-sonnet-4-5-20250929",
  tools: [getWeather],
});
 
// 実行
const result = await agent.invoke({
  messages: [{ role: "user", content: "東京の天気を教えて" }],
});
 
console.log(result);

import { createAgent, tool } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
import * as z from "zod";
 
const searchWeb = tool(
  ({ query }) => `「${query}」の検索結果: LangChain.jsは2022年に公開されたフレームワークです。`,
  {
    name: "search_web",
    description: "Webを検索して情報を取得する",
    schema: z.object({
      query: z.string().describe("検索クエリ"),
    }),
  }
);
 
// メモリを設定
const checkpointer = new MemorySaver();
 
const agent = createAgent({
  model: "claude-sonnet-4-5-20250929",
  tools: [searchWeb],
  systemPrompt: "あなたは親切な日本語のAIアシスタントです。",
  checkpointer,
});
 
// 同じthread_idを使うと会話が継続する
const config = { configurable: { thread_id: "session-1" } };
 
const res1 = await agent.invoke(
  { messages: [{ role: "user", content: "LangChain.jsって何？" }] },
  config,
);
console.log(res1.messages.at(-1)?.content);
 
// 会話の文脈を覚えている
const res2 = await agent.invoke(
  { messages: [{ role: "user", content: "それはいつ公開されたの？" }] },
  config,
);
console.log(res2.messages.at(-1)?.content);

import { createAgent } from "langchain";
import * as z from "zod";
 
// 出力スキーマを定義
const ContactInfo = z.object({
  name: z.string().describe("名前"),
  email: z.string().describe("メールアドレス"),
  phone: z.string().describe("電話番号"),
  company: z.string().optional().describe("会社名"),
});
 
const agent = createAgent({
  model: "gpt-4.1",
  responseFormat: ContactInfo,
});
 
const result = await agent.invoke({
  messages: [
    {
      role: "user",
      content: "山田太郎さん、yamada@example.com、03-1234-5678、株式会社テスト",
    },
  ],
});
 
console.log(result.structuredResponse);
// {
//   name: "山田太郎",
//   email: "yamada@example.com",
//   phone: "03-1234-5678",
//   company: "株式会社テスト"
// }

import * as z from "zod";
import { createAgent, tool } from "langchain";
 
// ベクトルストアからの検索をツール化
const retrieve = tool(
  async ({ query }) => {
    // vectorStoreは事前に構築済みのベクトルストア
    const docs = await vectorStore.similaritySearch(query, 3);
    return docs.map(
      (doc) => `[${doc.metadata.source}] ${doc.pageContent}`
    ).join("\n\n");
  },
  {
    name: "search_documents",
    description: "社内ドキュメントを検索して関連情報を取得する",
    schema: z.object({
      query: z.string().describe("検索クエリ"),
    }),
  }
);
 
const ragAgent = createAgent({
  model: "gpt-4.1",
  tools: [retrieve],
  systemPrompt: `あなたは社内ドキュメントに基づいて回答するアシスタントです。
必ずsearch_documentsツールで情報を検索してから回答してください。
情報が見つからない場合は、正直にその旨を伝えてください。`,
});
 
const result = await ragAgent.invoke({
  messages: [
    { role: "user", content: "有給休暇の申請方法を教えて" },
  ],
});

import { createAgent, dynamicSystemPromptMiddleware } from "langchain";
import { SystemMessage } from "@langchain/core/messages";
 
const agent = createAgent({
  model: "gpt-4.1",
  tools: [],
  middleware: [
    dynamicSystemPromptMiddleware(async (state) => {
      const lastQuery = state.messages[state.messages.length - 1].content;
 
      // ユーザーの質問でベクトル検索
      const docs = await vectorStore.similaritySearch(lastQuery, 3);
      const context = docs.map((d) => d.pageContent).join("\n\n");
 
      return new SystemMessage(
        `以下のコンテキストをもとに回答してください:\n\n${context}`
      );
    }),
  ],
});

const stream = await agent.stream(
  {
    messages: [
      { role: "user", content: "TypeScriptの主な特徴を5つ教えて" },
    ],
  },
  { streamMode: "values" },
);
 
for await (const chunk of stream) {
  const latestMessage = chunk.messages.at(-1);
 
  if (latestMessage?.tool_calls?.length) {
    // ツール呼び出し中
    const toolNames = latestMessage.tool_calls.map((tc) => tc.name);
    console.log(`ツール呼び出し中: ${toolNames.join(", ")}`);
  } else if (latestMessage?.content) {
    // テキスト応答
    console.log(latestMessage.content);
  }
}

import { ChatOpenAI } from "@langchain/openai";
import { createAgent, createMiddleware } from "langchain";
 
const lightModel = new ChatOpenAI({ model: "gpt-4.1-mini" });
const powerModel = new ChatOpenAI({ model: "gpt-4.1" });
 
const dynamicModelSelection = createMiddleware({
  name: "DynamicModelSelection",
  wrapModelCall: (request, handler) => {
    const messageCount = request.messages.length;
    // 会話が10往復を超えたら高性能モデルに切り替え
    const model = messageCount > 20 ? powerModel : lightModel;
    return handler({ ...request, model });
  },
});
 
const agent = createAgent({
  model: lightModel,
  tools: [/* ... */],
  middleware: [dynamicModelSelection],
});

import * as z from "zod";
import { createAgent, tool, type ToolRuntime } from "langchain";
 
type AgentRuntime = ToolRuntime<unknown, { userId: string; role: string }>;
 
const getUserProfile = tool(
  (_, config: AgentRuntime) => {
    const { userId, role } = config.context;
    return JSON.stringify({
      userId,
      role,
      name: userId === "u001" ? "田中" : "不明",
      plan: role === "admin" ? "Enterprise" : "Free",
    });
  },
  {
    name: "get_user_profile",
    description: "現在のユーザーのプロフィールを取得する",
    schema: z.object({}),
  }
);
 
const contextSchema = z.object({
  userId: z.string(),
  role: z.string(),
});
 
const agent = createAgent({
  model: "gpt-4.1",
  tools: [getUserProfile],
  contextSchema,
});
 
const result = await agent.invoke(
  { messages: [{ role: "user", content: "私のプランは？" }] },
  { context: { userId: "u001", role: "admin" } },
);

// プロバイダー指定の例
const agent1 = createAgent({ model: "openai:gpt-4.1", tools: [] });
const agent2 = createAgent({ model: "anthropic:claude-sonnet-4-5", tools: [] });