LangChain完全ガイドローカルLLM(Ollama)連携で作るRAG・エージェント【2026年7月最新版】

ローカルLLMを本気で活用するなら、単なるチャットではなくRAG（検索拡張生成）、エージェント、ツール呼び出しといった高度な機能を組み合わせたい局面が必ず来ます。その中核となるフレームワークが LangChain です。本記事では、Ollamaと組み合わせたローカルLLM構成に絞り、2026年7月時点の最新版 langchain 1.3.11（2026年6月22日リリース、v1.0系の後継安定版）を前提として、インストールから実用ワークフロー、LangGraphによるステートフルエージェント、LangSmithでの監視まで、この1記事で完結できるレベルまで徹底解説します。読者が公式ドキュメントを行き来せず、コピペで動作するコード例だけで自宅PCにローカルLLMアプリを構築できることをゴールにします。

LangChainとは何か
1. 階層構造の理解
最新リリース情報（2026年最新）
1. v1.0以降の主要な変更（時系列）
2. 以前のバージョンとの違い
他ツールとの比較
1. どれを選ぶべきか
メリット・デメリット
1. メリット
2. デメリット
動作要件
インストール手順
初期設定
1. 環境変数の設定
基本的な使い方
実践的な使い方
応用・カスタマイズ
パフォーマンス最適化
よくあるエラーとトラブルシューティング
おすすめの組み合わせ・連携
推奨PCスペック
まとめ
📦 この記事で紹介した商品

LangChainとは何か

LangChainは、langchain-ai/langchain が開発するオープンソースのLLMアプリケーション開発フレームワークです。2022年10月にHarrison Chase氏が公開した個人プロジェクトから始まり、GitHubスター数141k、依存プロジェクト数28万超という、Pythonエコシステムで最も採用されているLLMフレームワークに成長しました。ライセンスは商用利用可能なMITライセンスです。

LangChainのコアコンセプトは「Agent = Model + Harness」です。モデル、プロンプト、ツール、ミドルウェアといった構成要素を差し替え可能なパーツとして提供し、それらを最小限のコードで組み合わせるためのハーネス（枠組み）を用意しています。Ollama、llama.cpp、vLLM、Hugging Face TGIなど主要なローカル推論エンジンすべてに対応しているため、クラウドAPIからローカルへの移行、あるいはハイブリッド運用がコード変更ほぼゼロで実現できるのが最大の強みです。

階層構造の理解

LangChainファミリーは以下の4層で構成されます。この階層を理解することが、公式ドキュメントを読み解く第一歩です。

langchain-core: Runnable、Message、Toolなどの基底クラスと LangChain Expression Language（LCEL）を提供する土台
langchain: create_agent ハーネス、メモリ、リトリーバなど汎用アプリケーション部品を提供する本体
LangGraph: 決定論的フローとエージェント的フローを組み合わせた低レベルオーケストレーションフレームワーク。人手ループやチェックポイント、複雑な状態遷移が必要な本番用途で使う
LangSmith: 実行トレース、デバッグ、評価、モニタリングを提供するSaaS観測基盤（ローカル環境からも利用可能）

本記事では、まず langchain パッケージと langchain-ollama を使った基本を押さえ、後半で LangGraph と LangSmith に踏み込みます。

他ツールとの比較

LLMアプリケーションフレームワークの主要な選択肢はLangChain、LlamaIndex、Haystack、およびフレームワークを使わない生SDK直叩きの4つです。ローカルLLM運用の観点で比較します。

項目	LangChain 1.3.11	LlamaIndex 0.14.23	Haystack 2.30.2	生SDK（ollama-python等）
最新版リリース日	2026-06-22	2026-06-24	2026-06-18	継続更新
主眼	エージェント・汎用	RAG・ドキュメントQA	本番検索パイプライン	ミニマル
ローカルLLM対応	Ollama / llama.cpp / vLLM / TGI	Ollama / llama.cpp	Ollama / llama.cpp / HF	依存エンジン次第
抽象化の深さ	深い（LCEL、Runnable）	中（Query Engine）	中（Pipeline）	なし
フレームワーク overhead	約10ms	約6ms	約5.9ms	ほぼゼロ
トークン使用量（同一タスク）	約2.40k	約1.60k	約1.57k	約1.30k
統合エコシステム	700+ 統合	300+ 統合	100+ 統合	自作必要
学習コスト	高い	中	中	低い
本番監視	LangSmith 標準	Arize等外部	Elasticsearch連携	自作
日本語ドキュメント	コミュニティ多数	公式一部あり	少ない	N/A
推奨用途	複雑エージェント	純粋RAG	企業向け検索	単発API呼び出し

どれを選ぶべきか

2026年時点の判断基準は次の通りです。プロトタイピングを最速で回したいなら LangChain、RAGだけで完結する社内文書QAなら LlamaIndex、Elasticsearch連携やオンプレ本番検索なら Haystack、そして数十行以内で完結する用途なら生SDKで十分です。ただし途中でエージェント化やマルチステップ化する見込みがあるなら、後から書き直すコストを避けるためにLangChainで始めるのが安全です。

メリット・デメリット

メリット

圧倒的な統合数: Ollama、vLLM、Chroma、Qdrant、FAISS、Redis、PGVector、Neo4jなどベクトルDBや外部ツールの統合が公式パッケージとして提供される
モデル差し替えが1行: ChatOllama を ChatAnthropic や ChatOpenAI に変えるだけでプロバイダー変更が完了、ローカル/クラウドのハイブリッド運用が容易
LCEL によるパイプライン記述: prompt | llm | parser のような直感的な合成で、非同期・ストリーミング・バッチが自動的に対応
LangSmith による観測性: プロダクション運用で必須のトレース・評価・A/Bテスト機能が同一エコシステム内で完結
コミュニティの厚さ: GitHub Discussionsで日次数十件の質問投稿、Stack Overflowにも大量の実例がある

デメリット

抽象化のオーバーヘッド: 生SDKに比べて1リクエストあたり10ms前後のフレームワーク遅延、トークン使用量も約1.5〜2倍
破壊的変更の歴史: v0.1→v0.2→v0.3→v1.0とAPIが大きく変わってきた履歴があり、古い記事のコードがそのままでは動かない（v1.0以降は安定を約束）
依存関係が肥大化しやすい: 気軽に統合パッケージを追加していくと、langchain-community、langchain-experimental、各プロバイダーパッケージで数十のライブラリが入る
デバッグが難しい: 内部でプロンプトが加工されるため、実際にLLMに渡っている文字列を把握するにはLangSmithかverbose=True設定が必要
本番運用で生SDKに戻す事例も: 2026年に入り「LangChainからraw SDKへ書き直した」というブログ記事も増えており、大規模本番では設計判断が必要

動作要件

LangChain 本体のシステム要件は極めて軽量ですが、ローカルLLM運用ではOllamaが動くハードウェアが実質的な最小要件になります。

項目	最小	推奨（3B〜8Bモデル運用）	ハイエンド（14B〜70Bモデル運用）
Python	3.10 以上	3.11 または 3.12	3.11 または 3.12
OS	Windows 10 / macOS 12 / Ubuntu 20.04	Windows 11 / macOS 14 / Ubuntu 22.04	Windows 11 / macOS 15 / Ubuntu 24.04
GPU（NVIDIA）	不要（CPUでも動作可）	RTX 4060 8GB VRAM	RTX 5090 32GB VRAM または H100
GPU（Apple）	不要	M2 Pro 以上	M4 Max 以上
メモリ（RAM）	8GB	32GB DDR5	64GB DDR5 以上
ストレージ	10GB	500GB NVMe SSD	2TB NVMe SSD
Ollama バージョン	v0.29 以上	v0.31.1	v0.31.1

LangChain単体の動作なら Python 3.10以上と数百MBのディスク領域だけで足ります。エージェント化してツール呼び出しやRAGを構築するとPydantic、numpy、SQLAlchemyなどの依存関係で1〜2GB程度に膨らみます。

インストール手順

すべてのOSで共通の推奨手順は「uv による仮想環境作成 + pip install」です。uvはRust製の高速パッケージマネージャで、2026年時点ではLangChain公式もuvを推奨しています。

Windows（PowerShell）

# 1. uv をインストール（Python自動管理も可能）
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# 2. プロジェクトディレクトリ作成
mkdir langchain-local
cd langchain-local

# 3. Python 3.12 の仮想環境を作成
uv venv --python 3.12

# 4. 仮想環境を有効化
.\.venv\Scripts\Activate.ps1

# 5. LangChain と Ollama 統合をインストール
uv pip install langchain langchain-ollama langchain-community

# 6. 追加でRAG用ベクトルDB（Chroma）とテキスト分割ユーティリティ
uv pip install langchain-chroma langchain-text-splitters

# 7. インストール確認
python -c "import langchain, langchain_ollama; print(langchain.__version__, langchain_ollama.__version__)"

macOS（Homebrew + Terminal）

# 1. uv インストール
curl -LsSf https://astral.sh/uv/install.sh | sh

# 2. プロジェクト作成
mkdir langchain-local && cd langchain-local

# 3. 仮想環境作成（Apple SiliconではMLX統合も選択可）
uv venv --python 3.12
source .venv/bin/activate

# 4. LangChain と Ollama 統合をインストール
uv pip install langchain langchain-ollama langchain-community

# 5. Apple Silicon向けの追加パッケージ（任意）
uv pip install langchain-chroma langchain-text-splitters mlx-lm

# 6. 動作確認
python -c "from langchain_ollama import ChatOllama; print('OK')"

Linux（Ubuntu 22.04 以上）

# 1. システム依存パッケージ
sudo apt update
sudo apt install -y python3.12 python3.12-venv build-essential curl

# 2. uv インストール
curl -LsSf https://astral.sh/uv/install.sh | sh
source $HOME/.local/bin/env

# 3. プロジェクト作成
mkdir langchain-local && cd langchain-local
uv venv --python 3.12
source .venv/bin/activate

# 4. LangChain と Ollama 統合
uv pip install langchain langchain-ollama langchain-community langchain-chroma

# 5. NVIDIA GPU 環境ではCUDA版PyTorchも入れると埋め込み処理が高速化
uv pip install torch --index-url https://download.pytorch.org/whl/cu124

Ollama のインストールと起動

LangChainからローカルLLMを叩くにはOllamaが必須です。Ollama公式インストーラを使えばモデル管理とサーバー起動が自動化されます。

# Windows: 公式インストーラをダウンロードして実行（インストール後、自動でサーバー起動）
# https://ollama.com/download/windows

# macOS
brew install ollama
ollama serve &

# Linux
curl -fsSL https://ollama.com/install.sh | sh

# モデルの取得（例: 8GBクラスのGPU向け）
ollama pull llama3.2:3b
ollama pull qwen2.5:7b
ollama pull nomic-embed-text  # 埋め込み用

# サーバー稼働確認
curl http://localhost:11434/api/tags

初期設定

インストール後にまず確認するのは、LangChainからOllamaに対する疎通確認です。以下の3行スクリプトで動けば環境構築は完了です。

from langchain_ollama import ChatOllama

llm = ChatOllama(model="llama3.2:3b", temperature=0)
print(llm.invoke("こんにちは、自己紹介してください").content)

実行して自然な日本語で応答が返ってくれば正常です。エラーが出る場合は次の点を確認してください。

curl http://localhost:11434/api/tags でOllamaサーバーが応答するか
ollama list で対象モデル（例: llama3.2:3b）が実際にダウンロード済みか
Windowsではファイアウォールが11434ポートをブロックしていないか

環境変数の設定

LangSmithによるトレース記録を有効化したい場合は、以下の環境変数を設定します。無料アカウントで月5,000トレースまで利用できます。

export LANGCHAIN_TRACING_V2=true
export LANGCHAIN_API_KEY=lsv2_pt_xxxxxxxxxxxx
export LANGCHAIN_PROJECT=my-local-llm

Windowsの場合は $env:LANGCHAIN_TRACING_V2 = "true" のようにPowerShell構文で設定します。トレースを使わない場合はこの設定は不要です。

基本的な使い方

1. シンプルなチャット

from langchain_ollama import ChatOllama

llm = ChatOllama(
    model="qwen2.5:7b",
    temperature=0.7,
    num_ctx=8192,       # コンテキスト長（トークン数）
    num_predict=512,    # 最大生成トークン数
)

messages = [
    ("system", "あなたは日本語で回答する親切なアシスタントです。"),
    ("human", "LangChainの主な機能を3つ挙げてください。"),
]

response = llm.invoke(messages)
print(response.content)

2. ストリーミング出力

ChatGPTのような逐次表示は stream() メソッドで実現します。ローカルLLMではストリーミングによる体感速度改善の効果が大きいので、UIを持つアプリではほぼ必須の機能です。

for chunk in llm.stream("LCELとは何か100字で説明してください"):
    print(chunk.content, end="", flush=True)
print()

3. LCEL によるパイプライン

LangChain Expression Language（LCEL）は、プロンプト、モデル、パーサをパイプで連結する構文です。これにより、プロンプトテンプレートを差し替えたり、複数のモデルで並列実行したりが1行で書けます。

from langchain_ollama import ChatOllama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatOllama(model="qwen2.5:7b", temperature=0)

prompt = ChatPromptTemplate.from_messages([
    ("system", "あなたは{topic}の専門家です。日本語で回答してください。"),
    ("human", "{question}"),
])

chain = prompt | llm | StrOutputParser()

result = chain.invoke({
    "topic": "ローカルLLM",
    "question": "Ollamaで8GB VRAMのGPUに最適なモデルは何ですか？",
})
print(result)

4. 構造化出力

JSONスキーマに従った構造化データを取り出すには with_structured_output() を使います。Pydanticモデルで型を定義しておけば、レスポンスがそのまま型付きオブジェクトとして返ってきます。

from pydantic import BaseModel, Field
from langchain_ollama import ChatOllama

class BookReview(BaseModel):
    title: str = Field(description="書籍のタイトル")
    score: int = Field(description="評価点（1〜5）")
    summary: str = Field(description="200字以内の要約")
    recommended: bool = Field(description="推奨するかどうか")

llm = ChatOllama(model="qwen2.5:7b", temperature=0)
structured_llm = llm.with_structured_output(BookReview)

review = structured_llm.invoke("『ゼロから作るDeep Learning』を評価してください")
print(review.model_dump_json(indent=2))

実践的な使い方

ユースケース1: RAG（検索拡張生成）で社内文書Q&A

ローカル文書に対する質問応答は、ローカルLLMの最も需要が高いユースケースです。以下は PDF や Markdown を読み込んで質問応答を行う最小構成です。

from langchain_community.document_loaders import TextLoader, PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_ollama import OllamaEmbeddings, ChatOllama
from langchain_chroma import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

# 1. 文書の読み込み
loader = TextLoader("./docs/manual.md", encoding="utf-8")
docs = loader.load()

# 2. チャンク分割（1000文字、200文字オーバーラップ）
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(docs)

# 3. 埋め込みモデルとベクトルストア構築
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma.from_documents(chunks, embeddings, persist_directory="./chroma_db")
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

# 4. RAGチェーンの構築
prompt = ChatPromptTemplate.from_template(
    """以下のコンテキストのみを根拠に、質問に日本語で回答してください。
コンテキストに答えがない場合は「情報がありません」と答えてください。

コンテキスト:
{context}

質問: {question}"""
)

llm = ChatOllama(model="qwen2.5:7b", temperature=0)

def format_docs(docs):
    return "\n\n".join(d.page_content for d in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

print(rag_chain.invoke("インストール方法の要点を3つ挙げてください"))

この構成は persist_directory を指定しているため2回目以降はChromaの再構築が不要で、数秒で起動します。実務ではベクトルDBの永続化とロードを分離する運用が定番です。

ユースケース2: ツール呼び出しでリアルタイム情報にアクセス

LLMは自身の学習データ以降の情報を知りません。ツール呼び出し機能を使えば、天気APIや電卓、ファイルシステムなど外部リソースにアクセスできます。Ollamaのツール呼び出し対応モデル（Llama 3.2以降、Qwen2.5、Mistral Nemo等）が必要です。

from langchain_core.tools import tool
from langchain_ollama import ChatOllama

@tool
def get_weather(city: str) -> str:
    """指定した都市の現在の天気を返す。cityは日本語都市名。"""
    # 実運用ではOpenWeatherMap等のAPIを叩く
    mock_data = {"東京": "晴れ 25度", "大阪": "曇り 22度", "札幌": "雨 15度"}
    return mock_data.get(city, "不明")

@tool
def calculator(expression: str) -> float:
    """数式を評価する。例: '2 + 3 * 4'"""
    return eval(expression, {"__builtins__": {}})

llm = ChatOllama(model="qwen2.5:7b", temperature=0)
llm_with_tools = llm.bind_tools([get_weather, calculator])

response = llm_with_tools.invoke("東京の気温を確認して、それに5を足した数を計算してください")

for tool_call in response.tool_calls:
    print(f"呼び出しツール: {tool_call['name']}, 引数: {tool_call['args']}")

ユースケース3: create_agent による ReAct 型エージェント

ツール呼び出しを繰り返して自律的に問題解決するエージェントは create_agent で1行で構築できます。内部的にはLangGraphで動いており、複数ステップの推論とツール実行を自動化します。

from langchain.agents import create_agent
from langchain_ollama import ChatOllama
from langchain_core.tools import tool

@tool
def search_docs(query: str) -> str:
    """社内ドキュメントを検索する。"""
    return f"{query} に関するドキュメント: ..."

@tool
def send_slack(channel: str, message: str) -> str:
    """Slackにメッセージを送信する。"""
    return f"Slack #{channel} に投稿しました"

llm = ChatOllama(model="qwen2.5:7b", temperature=0)
agent = create_agent(llm, tools=[search_docs, send_slack])

result = agent.invoke({
    "messages": [{"role": "user", "content": "『LangChain インストール』の情報を検索して、#devチャンネルに要約を投稿して"}]
})
for msg in result["messages"]:
    print(f"[{msg.type}] {msg.content[:200]}")

応用・カスタマイズ

LangGraph によるステートフルワークフロー

複数のエージェントが分岐して協調する、あるいはヒューマンレビューを挟むといった複雑なフローには LangGraph 1.2.8 が必要です。ノードとエッジで状態遷移を定義するグラフベースの記述で、チェックポイントによる中断・再開もサポートします。

from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
from langgraph.graph.message import add_messages
from langchain_ollama import ChatOllama
from langchain_core.messages import HumanMessage, AIMessage

class AgentState(TypedDict):
    messages: Annotated[list, add_messages]
    step: int

llm = ChatOllama(model="qwen2.5:7b", temperature=0)

def researcher(state: AgentState):
    prompt = f"以下について調査結果を200字でまとめてください: {state['messages'][-1].content}"
    response = llm.invoke(prompt)
    return {"messages": [AIMessage(content=f"[調査] {response.content}")], "step": state["step"] + 1}

def writer(state: AgentState):
    prompt = f"以下の調査結果を元にブログ記事の見出し3つを作成: {state['messages'][-1].content}"
    response = llm.invoke(prompt)
    return {"messages": [AIMessage(content=f"[執筆] {response.content}")], "step": state["step"] + 1}

def should_continue(state: AgentState):
    return "writer" if state["step"] < 2 else END

graph = StateGraph(AgentState)
graph.add_node("researcher", researcher)
graph.add_node("writer", writer)
graph.set_entry_point("researcher")
graph.add_conditional_edges("researcher", should_continue, {"writer": "writer", END: END})
graph.add_edge("writer", END)

app = graph.compile()
result = app.invoke({"messages": [HumanMessage(content="ローカルLLMの最新動向")], "step": 0})
for msg in result["messages"]:
    print(msg.content[:200])

ミドルウェアの活用

v1.0で導入されたミドルウェアシステムは、エージェントの各ステップにフックを差し込むための仕組みです。ヒューマンインザループ（人間承認）、要約（長文コンテキストの圧縮）、ガードレール（プロンプトインジェクション対策）を、既存エージェントに1行で追加できます。

from langchain.agents import create_agent
from langchain.agents.middleware import HumanInTheLoopMiddleware, SummarizationMiddleware
from langchain_ollama import ChatOllama

llm = ChatOllama(model="qwen2.5:7b")

agent = create_agent(
    llm,
    tools=[send_slack, delete_file],
    middleware=[
        HumanInTheLoopMiddleware(tools=["delete_file"]),        # delete_fileは人間承認必須
        SummarizationMiddleware(max_tokens=4096, model=llm),   # コンテキストが4096トークン超で要約
    ],
)

LangSmith による観測とデバッグ

実運用では、なぜモデルがそう答えたかを追跡できないと改善サイクルが回りません。LangSmithは全リクエスト・全ツール呼び出しをタイムラインで可視化してくれます。無料枠は月5,000トレースなので、個人開発なら十分です。

import os
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "lsv2_pt_xxxxxxxxxxxx"
os.environ["LANGCHAIN_PROJECT"] = "rag-experiment"

# 上記を設定するだけで、以降すべてのLangChain呼び出しがLangSmithに送られる
from langchain_ollama import ChatOllama
llm = ChatOllama(model="qwen2.5:7b")
llm.invoke("テスト")  # https://smith.langchain.com にトレースが自動記録される

パフォーマンス最適化

1. 埋め込みキャッシュ

RAG構築時、同じチャンクを何度も埋め込み計算するのはCPU/GPU時間の無駄です。CacheBackedEmbeddings でファイルシステムにキャッシュしましょう。

from langchain.embeddings import CacheBackedEmbeddings
from langchain.storage import LocalFileStore
from langchain_ollama import OllamaEmbeddings

fs = LocalFileStore("./embedding_cache/")
underlying = OllamaEmbeddings(model="nomic-embed-text")
embeddings = CacheBackedEmbeddings.from_bytes_store(underlying, fs, namespace=underlying.model)

2. Ollama のコンテキスト長を絞る

num_ctx のデフォルトは2048ですが、モデルの上限まで広げるとVRAM消費が急増します。RAGでは4096〜8192、単純なチャットなら2048で十分です。過剰なコンテキストは応答遅延の主因になります。

3. バッチ処理と非同期

大量の質問を一気に処理する場合、batch() か abatch() を使うと Ollama への並列リクエストが自動で実行されます。GPU使用率を100%近くまで押し上げられます。

import asyncio
from langchain_ollama import ChatOllama

llm = ChatOllama(model="qwen2.5:7b")

questions = ["Pythonとは？", "Rustとは？", "Goとは？"]
results = llm.batch(questions)  # 同期並列

async def main():
    return await llm.abatch(questions)  # 非同期並列

# print(asyncio.run(main()))

4. 量子化モデルの選択

Ollamaのモデルタグには q4_K_M、q8_0 のような量子化レベルが含まれます。q4_K_M（4bit）はVRAM消費を約半分にでき、体感品質の低下は限定的です。Llama 3.2:3b-instruct-q4_K_M なら4GB VRAMでも余裕で動きます。

5. LangChain のオーバーヘッド削減

単純なチャットで LangChain のパイプラインが不要な場面では、直接 ollama-python を叩く方が10ms早くなります。エージェント化する前段のプロトタイプでは無理に LangChain を使わない選択もあります。

よくあるエラーとトラブルシューティング

エラー1: ConnectionError: Failed to connect to Ollama

原因: Ollamaサーバーが起動していない、またはポート11434が閉じている。

対処:

# Ollamaサーバー状態確認
curl http://localhost:11434/api/tags

# 起動していない場合
ollama serve &

# 別ホストで動いている場合はChatOllamaで base_url を指定
# ChatOllama(model="qwen2.5:7b", base_url="http://192.168.1.100:11434")

エラー2: KeyError: 'model' when calling invoke

原因: 指定したモデル名がOllamaに存在しない。タグを含めた完全一致が必要。

対処: ollama list で正確なモデル名を確認し、llama3.2 ではなく llama3.2:3b のようにタグまで書く。

エラー3: OutOfMemoryError（VRAM不足）

原因: モデルサイズがVRAMを超えている、または num_ctx が大きすぎる。

対処: より小さい量子化バージョン（q4_K_M）に切り替え、num_ctx を2048〜4096に縮小。Ollamaが OLLAMA_NUM_GPU=0 でCPUフォールバックする設定も有効。

エラー4: ValidationError from Pydantic in with_structured_output

原因: LLMが返したJSONがPydanticスキーマに一致しない。ローカルLLMは大規模モデルよりスキーマ遵守が弱いことがある。

対処: プロンプトに例示を追加、method="json_schema" を明示、または Qwen2.5:14b のような構造化出力が得意な大きめモデルに切り替える。

structured_llm = llm.with_structured_output(BookReview, method="json_schema")

エラー5: ImportError: cannot import name 'AgentExecutor'

原因: v1.0で AgentExecutor は非推奨になり、langchain.agents からのインポートパスが変わった。

対処: from langchain.agents import create_agent または from langgraph.prebuilt import create_react_agent に置き換え。

エラー6: 応答が途中で切れる

原因: num_predict（最大生成トークン数）が小さすぎる。デフォルトは128の場合がある。

対処: ChatOllama(num_predict=2048) のように明示的に指定する。

エラー7: Chromaがロックされて起動しない

原因: 前回のプロセスが持続接続を保ったまま終了、または複数プロセスから同じ persist_directory にアクセス。

対処: chroma_db/ フォルダごとバックアップして削除、再構築。本番運用ではChroma Server モードに切り替える。

推奨PCスペック

LangChainでローカルLLMを本気で運用する場合、実際に組む3つの構成例を用途別に示します。

パーツ	入門（3Bモデル中心）	標準（7B〜14B）	ハイエンド（32B〜70B）
CPU	Ryzen 5 7600 / Core i5-14400F	Ryzen 7 9700X / Core i7-14700K	Ryzen 9 9950X / Core i9-14900K
GPU	RTX 4060 8GB	RTX 4070 Ti SUPER 16GB	RTX 5090 32GB または RTX 5080 16GB×2
メモリ	16GB DDR5 5200	32GB DDR5 6000	64GB DDR5 6000
SSD	500GB NVMe Gen4	2TB NVMe Gen4	2TB NVMe Gen5
電源	650W 80+ Bronze	850W 80+ Gold	1200W 80+ Platinum
合計目安	約16万円	約35万円	約75万円
想定用途	個人チャット、簡易RAG	本格RAG、エージェント、開発	企業内推論サーバー、複数モデル同時

2026年時点では、RTX 4070 Ti SUPER 16GB がコスパと汎用性で最有力です。7B〜14BクラスのLLMを q4 量子化で快適に動かせ、埋め込みモデルと同時ロードもできます。RTX 4060 8GBでも3B〜7B q4 量子化なら十分実用域ですが、ミドルウェアやツールが増えたときに窮屈です。

まとめ

LangChain 1.3.11（2026年6月時点）は、v1.0系の安定化により学習曲線が急峻だった過去とは別物に生まれ変わっています。とくにOllamaとの統合パッケージ langchain-ollama は成熟しており、ローカルLLMでツール呼び出しや構造化出力、RAG、エージェントといった高度な機能を、クラウドAPIと同じコードベースで実現できるのが大きな魅力です。

本記事のコード例はすべてコピペで動作します。まずはRAGとエージェントの2つを手元の環境で動かし、次に LangGraph でフローを組み、最後に LangSmith で観測性を確保する、というステップアップを推奨します。公式ロードマップでは、次期v1.4以降でマルチモーダル対応の強化とMCP（Model Context Protocol）統合が予定されており、ローカルLLM周辺のエコシステムは今後も拡大の一途です。

本ブログでは warokai.com で今後もローカルLLM、Ollama、LangChain、LangGraphの実践ガイドを継続的に発信していきます。次回はLangGraphによる本格エージェントの設計パターンを予定しています。

📦 この記事で紹介した商品

大規模言語モデル入門 → Amazonで見る
NVIDIA GeForce RTX 4070 Ti SUPER → Amazonで見る
RAG実践ガイド → Amazonで見る
Samsung 990 PRO 2TB NVMe SSD → Amazonで見る
DDR5メモリ 32GB → Amazonで見る

※ 上記リンクはAmazonアソシエイトリンクです。購入いただくと当サイトに紹介料が入ります。