LangChain入門：AIアプリケーション開発の新時代

はじめに

人工知能（AI）の世界は日々進化を続けており、その中でもLangChainは大きな注目を集めています。LangChainは、大規模言語モデル（LLM）を活用したアプリケーション開発を効率化するためのフレームワークです。本記事では、LangChainの基本から応用まで、15の章を通じて詳しく解説していきます。

記事に新しい章を追加し、LangChainのインストールについて説明します。以下は、既存の記事構成に合わせた新しい章の提案です。

はじめに②LangChainのインストールと環境設定

LangChainを使用するには、まず適切にインストールし、環境を設定する必要があります。以下に、インストール手順と基本的な環境設定を説明します。

LangChainは、Pythonのパッケージマネージャーであるpipを使用して簡単にインストールできます。以下のコマンドを実行してください：

pip install langchain

OpenAIのAPIを使用する場合は、追加で以下のパッケージもインストールしてください：

pip install openai

環境変数の設定

LangChainを使用する際、特に外部APIを利用する場合は、適切な環境変数を設定する必要があります。例えば、OpenAIのAPIキーを設定するには以下のようにします：

import os
os.environ["OPENAI_API_KEY"] = "あなたのOpenAI APIキー"

セキュリティ上の理由から、APIキーを直接コードに記述するのではなく、環境変数として設定することをお勧めします。

基本的な使用例

インストールと環境設定が完了したら、以下のような簡単なコードでLangChainの動作を確認できます：

from langchain.llms import OpenAI

llm = OpenAI(temperature=0.9)
text = "What would be a good company name for a company that makes colorful socks?"
print(llm(text))

このコードは、OpenAIのモデルを使用して、カラフルな靴下を製造する会社の名前を生成します。

注意点

• LangChainは活発に開発が進められているため、定期的に最新バージョンにアップデートすることをお勧めします。
• 使用するAPIやサービスによっては、追加のパッケージのインストールや設定が必要な場合があります。
• APIの使用には料金が発生する場合があるため、利用規約と料金体系を確認してください。

以上の手順で、LangChainを使用するための基本的な環境が整います。

第1章：LangChainとは

LangChainは、AIアプリケーション開発を簡素化するためのオープンソースライブラリです。大規模言語モデル（LLM）を中心に、様々なAI関連のタスクを効率的に実行するためのツールセットを提供しています。

from langchain import LLMChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

# LangChainの基本的な使用例
llm = OpenAI(temperature=0.9)
prompt = PromptTemplate(
    input_variables=["product"],
    template="What is a good name for a company that makes {product}?",
)
chain = LLMChain(llm=llm, prompt=prompt)

# 製品名を入力して会社名を生成
print(chain.run("eco-friendly water bottles"))

第2章：LangChainの主要コンポーネント

LangChainは、モデル、プロンプト、メモリ、チェーン、エージェントなど、複数の重要なコンポーネントで構成されています。これらのコンポーネントを組み合わせることで、複雑なAIアプリケーションを構築できます。

from langchain.prompts import (
    ChatPromptTemplate,
    MessagesPlaceholder,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate
)
from langchain.chains import ConversationChain
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory

# チャットプロンプトの作成
prompt = ChatPromptTemplate.from_messages([
    SystemMessagePromptTemplate.from_template("The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know."),
    MessagesPlaceholder(variable_name="history"),
    HumanMessagePromptTemplate.from_template("{input}")
])

# メモリの設定
memory = ConversationBufferMemory(return_messages=True)

# 会話チェーンの作成
conversation = ConversationChain(
    memory=memory,
    prompt=prompt,
    llm=ChatOpenAI(temperature=0)
)

# 会話の実行
print(conversation.predict(input="Hi there!"))

第3章：プロンプトエンジニアリング

プロンプトエンジニアリングは、LangChainを使用する上で非常に重要な概念です。適切なプロンプトを設計することで、AIモデルからより正確で有用な回答を得ることができます。

from langchain import PromptTemplate

# プロンプトテンプレートの作成
template = """
You are a helpful assistant that translates {input_language} to {output_language}.

Translate the following text:
{text}

Translation:
"""

prompt = PromptTemplate(
    input_variables=["input_language", "output_language", "text"],
    template=template
)

# プロンプトの使用
print(prompt.format(input_language="English", output_language="French", text="Hello, how are you?"))

第4章：チェーンの構築

チェーンは、LangChainの中核的な概念の1つです。複数のコンポーネントを連結して、より複雑なタスクを実行することができます。

from langchain.chains import SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

# LLMの初期化
llm = OpenAI(temperature=0.7)

# 最初のチェーン：製品のアイデアを生成
first_prompt = PromptTemplate(
    input_variables=["product"],
    template="What is a good name for a company that makes {product}?",
)
chain_one = LLMChain(llm=llm, prompt=first_prompt)

# 二番目のチェーン：会社の説明を生成
second_prompt = PromptTemplate(
    input_variables=["company_name"],
    template="Write a catchphrase for the following company: {company_name}",
)
chain_two = LLMChain(llm=llm, prompt=second_prompt)

# チェーンの連結
overall_chain = SimpleSequentialChain(chains=[chain_one, chain_two], verbose=True)

# チェーンの実行
print(overall_chain.run("eco-friendly water bottles"))

第5章：メモリの活用

メモリコンポーネントを使用することで、会話の文脈を保持し、より自然な対話を実現することができます。

from langchain.memory import ConversationBufferMemory
from langchain.llms import OpenAI
from langchain.chains import ConversationChain

# メモリの初期化
memory = ConversationBufferMemory()

# 会話チェーンの作成
conversation = ConversationChain(
    llm=OpenAI(temperature=0),
    memory=memory,
    verbose=True
)

# 会話の実行
print(conversation.predict(input="Hi, my name is Alice"))
print(conversation.predict(input="What's my name?"))
print(conversation.predict(input="What have we talked about so far?"))

第6章：ドキュメント検索と質問応答

LangChainを使用して、大量のドキュメントから情報を検索し、質問に答えるシステムを構築することができます。

from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import CharacterTextSplitter
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA

# テキストの準備
with open('your_document.txt', 'r') as file:
    raw_text = file.read()

# テキストの分割
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_text(raw_text)

# ベクトルストアの作成
embeddings = OpenAIEmbeddings()
docsearch = Chroma.from_texts(texts, embeddings, metadatas=[{"source": str(i)} for i in range(len(texts))])

# 質問応答チェーンの作成
qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=docsearch.as_retriever())

# 質問の実行
query = "What is the main topic of this document?"
print(qa.run(query))

第7章：エージェントの活用

エージェントは、LangChainの中でも特に強力な機能の1つです。複数のツールを組み合わせて、より複雑なタスクを自律的に実行することができます。

from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.agents import AgentType
from langchain.llms import OpenAI

# LLMの初期化
llm = OpenAI(temperature=0)

# ツールの読み込み
tools = load_tools(["serpapi", "llm-math"], llm=llm)

# エージェントの初期化
agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

# エージェントの実行
agent.run("What was the high temperature in SF yesterday in Fahrenheit? What is that number raised to the .023 power?")

第8章：外部APIとの連携

LangChainを使用して、外部APIと連携することで、より豊富な情報源を活用したAIアプリケーションを構築できます。

from langchain.utilities import OpenWeatherMapAPIWrapper
from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI

# OpenWeatherMap APIの初期化
weather = OpenWeatherMapAPIWrapper()

# ツールの定義
tools = [
    Tool(
        name="Weather",
        func=weather.run,
        description="useful for when you need to answer questions about the weather"
    )
]

# エージェントの初期化
agent = initialize_agent(tools, OpenAI(temperature=0), agent="zero-shot-react-description", verbose=True)

# エージェントの実行
agent.run("What's the weather like in Tokyo right now?")

第9章：テキスト要約

LangChainを使用して、長文のテキストを効率的に要約することができます。

from langchain.chains.summarize import load_summarize_chain
from langchain.llms import OpenAI
from langchain.docstore.document import Document

# テキストの準備
text = """
LangChain is a framework for developing applications powered by language models. It enables applications that:
Are context-aware: connect a language model to sources of context (prompt instructions, few shot examples, content to ground its response in, etc.)
Reason: rely on a language model to reason (about how to answer based on provided context, what actions to take, etc.)
"""

# ドキュメントの作成
docs = [Document(page_content=text)]

# 要約チェーンの作成
chain = load_summarize_chain(OpenAI(temperature=0), chain_type="stuff")

# 要約の実行
print(chain.run(docs))

第10章：感情分析

LangChainを使用して、テキストの感情分析を行うことができます。

from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
from langchain.chains import LLMChain

# プロンプトテンプレートの作成
template = """
Analyze the sentiment of the following text:

Text: {text}

Sentiment (positive/negative/neutral):
"""

prompt = PromptTemplate(
    input_variables=["text"],
    template=template
)

# チェーンの作成
chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)

# 感情分析の実行
text = "I love using LangChain for AI development. It's so powerful and easy to use!"
print(chain.run(text))

第11章：多言語対応

LangChainを使用して、多言語対応のアプリケーションを構築することができます。

from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage

chat = ChatOpenAI(temperature=0)

messages = [
    SystemMessage(content="You are a helpful assistant that translates English to Japanese."),
    HumanMessage(content="Translate the following English text to Japanese: 'Hello, how are you?'")
]

print(chat(messages).content)

messages.append(HumanMessage(content="Now translate this to French: 'I love programming'"))

print(chat(messages).content)

第12章：カスタムツールの作成

LangChainでは、独自のカスタムツールを作成して、エージェントに組み込むことができます。

from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent
from langchain.prompts import StringPromptTemplate
from langchain import OpenAI, SerpAPIWrapper, LLMChain
from typing import List, Union
from langchain.schema import AgentAction, AgentFinish

# カスタムプロンプトテンプレート
class CustomPromptTemplate(StringPromptTemplate):
    template: str
    tools: List[Tool]
    
    def format(self, **kwargs) -> str:
        intermediate_steps = kwargs.pop("intermediate_steps")
        thoughts = ""
        for action, observation in intermediate_steps:
            thoughts += action.log
            thoughts += f"\nObservation: {observation}\nThought: "
        kwargs["agent_scratchpad"] = thoughts
        kwargs["tools"] = "\n".join([f"{tool.name}: {tool.description}" for tool in self.tools])
        kwargs["tool_names"] = ", ".join([tool.name for tool in self.tools])
        return self.template.format(**kwargs)

# カスタムツールの定義
def random_word(word: str) -> str:
    return f"A random word related to {word} is: example"

# ツールの設定
search = SerpAPIWrapper()
tools = [
    Tool(
        name = "Search",
        func=search.run,
        description="useful for when you need to answer questions about current events"
    ),
    Tool(
        name = "RandomWord",
        func=random_word,
        description="useful for when you need a random word related to a given word"
    )
]

# プロンプトテンプレートの設定
prompt = CustomPromptTemplate(
    template="Answer the following questions as best you can. You have access to the following tools:\n\n{tools}\n\nUse the following format:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction: the action to take, should be one of [{tool_names}]\nAction Input: the input to the action\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n\nBegin!\n\nQuestion: {input}\nThought:{agent_scratchpad}",
    tools=tools,
)

# 出力パーサーの設定
class CustomOutputParser:
    def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
        if "Final Answer:" in llm_output:
            return AgentFinish(
                return_values={"output": llm_output.split("Final Answer:")[-1].strip()},
                log=llm_output,
            )
        regex = r"Action: (.*?)\nAction Input: (.*)"
        match = re.search(regex, llm_output, re.DOTALL)
        if not match:
            raise ValueError(f"Could not parse LLM output: `{llm_output}`")
        action = match.group(1).strip()
        action_input = match.group(2).strip()
        return AgentAction(tool=action, tool_input=action_input, log=llm_output)

output_parser = CustomOutputParser()

# LLMチェーンの作成
llm = OpenAI(temperature=0)
llm_chain = LLMChain(llm=llm, prompt=prompt)

# エージェントの作成
tool_names = [tool.name for tool in tools]
agent = LLMSingleActionAgent(
    llm_chain=llm_chain, 
    output_parser=output_parser,
    stop=["\nObservation:"], 
    allowed_tools=tool_names
)

# エージェントの実行
agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True)
agent_executor.run("What's a random word related to 'programming'?")

第13章：データベース統合

LangChainを使用して、データベースと統合し、構造化されたデータに基づいて質問に答えるシステムを構築できます。

from langchain import OpenAI, SQLDatabase, SQLDatabaseChain

# データベースの接続
db = SQLDatabase.from_uri("sqlite:///chinook.db")

# LLMの初期化
llm = OpenAI(temperature=0)

# データベースチェーンの作成
db_chain = SQLDatabaseChain(llm=llm, database=db, verbose=True)

# クエリの実行
query = "How many tracks are there in the album with ID 1?"
print(db_chain.run(query))

第14章：音声認識と合成

LangChainを使用して、音声認識と音声合成を組み込んだアプリケーションを作成できます。

from langchain.llms import OpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
import speech_recognition as sr
import pyttsx3

# 音声認識の設定
recognizer = sr.Recognizer()

# 音声合成の設定
engine = pyttsx3.init()

# LLMチェーンの設定
llm = OpenAI(temperature=0.7)
prompt = PromptTemplate(
    input_variables=["query"],
    template="You are a helpful assistant. Answer the following query: {query}"
)
chain = LLMChain(llm=llm, prompt=prompt)

# 音声認識
with sr.Microphone() as source:
    print("Speak your question:")
    audio = recognizer.listen(source)

try:
    # 音声をテキストに変換
    query = recognizer.recognize_google(audio)
    print(f"You said: {query}")

    # LLMで回答を生成
    response = chain.run(query)
    print(f"AI response: {response}")

    # 回答を音声で出力
    engine.say(response)
    engine.runAndWait()

except sr.UnknownValueError:
    print("Sorry, I couldn't understand that.")
except sr.RequestError as e:
    print(f"Could not request results; {e}")

第15章：LangChainのベストプラクティスと最適化

LangChainを効果的に使用するためのベストプラクティスと、パフォーマンスを最適化するためのテクニックを紹介します。

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.cache import InMemoryCache
import langchain
import time

# キャッシュの設定
langchain.llm_cache = InMemoryCache()

# LLMの初期化（低温度設定で一貫性を向上）
llm = OpenAI(temperature=0.1)

# プロンプトテンプレートの最適化
template = """
You are an AI assistant specialized in {topic}.
Please provide a concise answer to the following question:
Question: {question}
Answer:
"""

prompt = PromptTemplate(
    input_variables=["topic", "question"],
    template=template
)

# チェーンの作成
chain = LLMChain(llm=llm, prompt=prompt)

# パフォーマンス測定
start_time = time.time()

# 複数回の実行（キャッシュの効果を確認）
for _ in range(5):
    response = chain.run(topic="Python programming", question="What is a list comprehension?")
    print(response)

end_time = time.time()
print(f"Execution time: {end_time - start_time} seconds")

# エラーハンドリングの例
try:
    invalid_response = chain.run(topic="Invalid topic", question="This will cause an error")
except Exception as e:
    print(f"An error occurred: {e}")
    # ここでエラーログを記録したり、フォールバックの処理を行ったりします

# リソースの解放
del llm
del chain

以上が、LangChainに関する15章構成の記事です。各章で、LangChainの主要な機能と概念を詳しく解説し、実践的なコード例を提供しました。この記事を通じて、読者がLangChainの基本から応用まで幅広く理解し、自身のAIアプリケーション開発に活用できるようになることを願っています。