LangChain 開発

このスキルを使用する場合

このスキルを使用する場合	代わりにシブリングスキルを使用する場合
LCEL チェーン(プロンプト → モデル → パーサー)または RAG パイプラインを構築する場合	ステートフルなグラフワークフローが必要な場合 — langgraph-agents を使用してください
チャットモデル、プロンプトテンプレート、またはツールバインディングを操作する場合	階層的なマルチエージェントオーケストレーションが必要な場合 — deep-agents を使用してください
既存の TypeScript プロジェクトに LangChain を追加する場合	新規プロジェクトをスキャフォルディングしている場合 — langchain-init(/langchain:init) を使用してください
ドキュメントローダーとベクトルストアを実装する場合	LangChain を使用しないワンオフの SDK 呼び出しのみが必要な場合 — プロバイダーの SDK を直接使用してください

コアの専門知識

LangChain JS/TS は LLM アプリケーション構築のためのフレームワークです。

• モデルプロバイダー全体での統一インターフェース(OpenAI、Anthropic、Google など)
• 構成可能なチェーンとエージェント
• 組み込みツール統合
• RAG(検索拡張生成)のサポート
• LangSmith 可観測性統合

インストール

パッケージマネージャーの設定

# コアパッケージ
npm install langchain
# または
pnpm add langchain
# または
bun add langchain

# モデルプロバイダーパッケージ(必要なものをインストール)
npm install @langchain/openai
npm install @langchain/anthropic
npm install @langchain/google-genai

# 一般的な統合
npm install @langchain/community  # コミュニティ統合
npm install @langchain/textsplitters  # ドキュメント分割

TypeScript 構成

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "esModuleInterop": true,
    "strict": true
  }
}

チャットモデル

基本的な使用方法

import { ChatOpenAI } from "@langchain/openai";
import { ChatAnthropic } from "@langchain/anthropic";
import { HumanMessage, SystemMessage } from "@langchain/core/messages";

// OpenAI
const openai = new ChatOpenAI({
  model: "gpt-4o",
  temperature: 0,
});

// Anthropic
const anthropic = new ChatAnthropic({
  model: "claude-haiku",
  temperature: 0,
});

// メッセージで呼び出し
const response = await openai.invoke([
  new SystemMessage("You are a helpful assistant."),
  new HumanMessage("Hello!"),
]);

ストリーミング

const stream = await openai.stream([new HumanMessage("Tell me a story")]);

for await (const chunk of stream) {
  process.stdout.write(chunk.content as string);
}

構造化出力

import { z } from "zod";

const schema = z.object({
  name: z.string().describe("The name"),
  age: z.number().describe("The age"),
});

const structuredLlm = openai.withStructuredOutput(schema);
const result = await structuredLlm.invoke("John is 30 years old");
// { name: "John", age: 30 }

プロンプトテンプレート

基本テンプレート

import { ChatPromptTemplate } from "@langchain/core/prompts";

const prompt = ChatPromptTemplate.fromMessages([
  ["system", "You are a {role}."],
  ["human", "{input}"],
]);

const formatted = await prompt.invoke({
  role: "helpful assistant",
  input: "Hello!",
});

フューショットプロンプト

import { FewShotChatMessagePromptTemplate } from "@langchain/core/prompts";

const examples = [
  { input: "2+2", output: "4" },
  { input: "3+3", output: "6" },
];

const fewShotPrompt = new FewShotChatMessagePromptTemplate({
  examplePrompt: ChatPromptTemplate.fromMessages([
    ["human", "{input}"],
    ["ai", "{output}"],
  ]),
  examples,
  inputVariables: ["input"],
});

チェーン(LCEL)

基本的なチェーン

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const prompt = ChatPromptTemplate.fromTemplate("Tell me a joke about {topic}");
const model = new ChatOpenAI();
const parser = new StringOutputParser();

// パイプ演算子でチェーンを構成
const chain = prompt.pipe(model).pipe(parser);

const result = await chain.invoke({ topic: "programming" });

並列チェーン

import { RunnableParallel } from "@langchain/core/runnables";

const parallel = RunnableParallel.from({
  joke: jokeChain,
  poem: poemChain,
});

const results = await parallel.invoke({ topic: "cats" });
// { joke: "...", poem: "..." }

分岐

import { RunnableBranch } from "@langchain/core/runnables";

const branch = RunnableBranch.from([
  [(x) => x.type === "math", mathChain],
  [(x) => x.type === "code", codeChain],
  defaultChain, // フォールバック
]);

ツール

ツールの定義

import { tool } from "@langchain/core/tools";
import { z } from "zod";

const calculatorTool = tool(
  async ({ a, b, operation }) => {
    switch (operation) {
      case "add":
        return String(a + b);
      case "subtract":
        return String(a - b);
      case "multiply":
        return String(a * b);
      case "divide":
        return String(a / b);
    }
  },
  {
    name: "calculator",
    description: "Performs basic arithmetic",
    schema: z.object({
      a: z.number(),
      b: z.number(),
      operation: z.enum(["add", "subtract", "multiply", "divide"]),
    }),
  },
);

ツールバインディング

const modelWithTools = model.bindTools([calculatorTool]);

const response = await modelWithTools.invoke("What is 25 * 4?");

// ツール呼び出しをチェック
if (response.tool_calls?.length) {
  const toolCall = response.tool_calls[0];
  const result = await calculatorTool.invoke(toolCall.args);
}

RAG(検索拡張生成)

ドキュメント読み込み

import { TextLoader } from "langchain/document_loaders/fs/text";
import { PDFLoader } from "@langchain/community/document_loaders/fs/pdf";
import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";

// ドキュメントを読み込み
const loader = new TextLoader("./data/document.txt");
const docs = await loader.load();

// チャンクに分割
const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200,
});
const splitDocs = await splitter.splitDocuments(docs);

ベクトルストア

import { MemoryVectorStore } from "langchain/vectorstores/memory";
import { OpenAIEmbeddings } from "@langchain/openai";

const embeddings = new OpenAIEmbeddings();
const vectorStore = await MemoryVectorStore.fromDocuments(
  splitDocs,
  embeddings,
);

// 検索
const results = await vectorStore.similaritySearch("query", 4);

RAG チェーン

import { createRetrievalChain } from "langchain/chains/retrieval";
import { createStuffDocumentsChain } from "langchain/chains/combine_documents";

const retriever = vectorStore.asRetriever({ k: 4 });

const combineDocsChain = await createStuffDocumentsChain({
  llm: model,
  prompt: ChatPromptTemplate.fromTemplate(`
    Answer based on this context:
    {context}

    Question: {input}
  `),
});

const ragChain = await createRetrievalChain({
  retriever,
  combineDocsChain,
});

const response = await ragChain.invoke({
  input: "What is the document about?",
});

エージェント(ReAct)

基本的なエージェント

import { createReactAgent } from "@langchain/langgraph/prebuilt";

const agent = createReactAgent({
  llm: model,
  tools: [calculatorTool, searchTool],
});

const result = await agent.invoke({
  messages: [{ role: "user", content: "Calculate 25 * 4" }],
});

エージェント最適化

コンテキスト	コマンド/パターン
クイックテスト	npx tsx --test src/**/*.test.ts
型チェック	npx tsc --noEmit
デバッグトレース	LANGCHAIN_TRACING_V2=true を設定
トークン削減	テキストのみの場合は StringOutputParser を使用
ストリーム出力	.invoke() の代わりに .stream() を使用
バッチリクエスト	並列処理の場合は .batch([inputs]) を使用
レスポンスキャッシング	繰り返し呼び出しの場合は InMemoryCache を使用

クイックリファレンス

環境変数

変数	説明
OPENAI_API_KEY	OpenAI API キー
ANTHROPIC_API_KEY	Anthropic API キー
LANGCHAIN_TRACING_V2	LangSmith トレーシングを有効化
LANGCHAIN_API_KEY	LangSmith API キー
LANGCHAIN_PROJECT	LangSmith プロジェクト名

一般的なインポート

インポート	パッケージ
ChatOpenAI	@langchain/openai
ChatAnthropic	@langchain/anthropic
ChatPromptTemplate	@langchain/core/prompts
StringOutputParser	@langchain/core/output_parsers
tool	@langchain/core/tools
RunnableSequence	@langchain/core/runnables

主要パッケージ

パッケージ	目的
langchain	コアフレームワーク
@langchain/core	基本抽象化
@langchain/openai	OpenAI 統合
@langchain/anthropic	Anthropic 統合
@langchain/community	コミュニティ統合
@langchain/langgraph	グラフベースのエージェント