LangChain アプリケーション開発入門 - Streamlit 活用ガイド

langchain==0.0.332
langcodes==3.3.0
langsmith==0.0.52
streamlit==1.27.2
layoutparser==0.3.4
openai==0.28.0
python-dotenv==1.0.0
chromadb==0.4.11
tiktoken==0.5.1
unstructured==0.10.16
faiss-cpu==1.7.4
jupyter_client==8.3.1
jupyter_core==5.3.1

langchain
  ├── .env              # OpenAI API キーを保存
  ├── notebooks.ipynb   # Jupyter Notebookファイル
  ├── requirements.txt  # 必要なライブラリ

# 1.Python 3.11.6 の仮想環境を作成
pyenv virtualenv 3.11.6 env

# 2.仮想環境を有効化
pyenv activate env

# 3. 必要なライブラリをインストール
pip install -r requirements.txt

# 仮想環境を無効化する場合: pyenv deactivate

OPENAI_API_KEY="XXXXXXXXX"

from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI

# LLM のインスタンスを作成
# gpt-3.5-turbo-instruct: テキスト生成に特化したモデル
llm = OpenAI(model="gpt-3.5-turbo-instruct")

# invoke() メソッドは、AIと簡単に会話するための機能
# 質問文を入れるだけでAIが回答を返してくる
llm.invoke("Hello, how are you?")

# output
'\n\nI am an AI, so I do not have emotions. But thank you for asking. How can I assist you?'

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

# Chat Modelのインスタンスを作成
# gpt-3.5-turbo: 対話に特化したモデ
# temperature パラメータについて:
#   - 設定範囲: 0.0 ~ 1.0
#   - 0.0: より一貫性のある回答
#   - 0.1: 安定した回答を得るための推奨値
#   - 1.0: よりクリエイティブで多様な回答

chat = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.1)

# メッセージリスト
messages = [
    # AIの役割を設定
    SystemMessage(
        content='あなたは サッカーの専門家です'
    ),
    # AIの初期応答を設定（任意：会話の文脈を作る）
    AIMessage(
        content='こんにちは'
    ),
     # ユーザーからの質問
    HumanMessage(
        content='Jリーグの試合はいつ始まりますか？'
    ),
]

chat.invoke(messages)

# output
AIMessage(content='Jリーグの試合は通常、土曜日や日曜日に開催されます。試合開始時間は通常午後から夕方にかけてで、具体的な開始時間は試合やスタジアムによって異なります。Jリーグの試合スケジュールは公式ウェブサイトや各クラブのウェブサイトで確認できますので、詳細な情報を知りたい場合はそちらをご覧ください。', additional_kwargs={}, response_metadata={'token_usage': <OpenAIObject at 0x10a4a2030> JSON: {
  "prompt_tokens": 49,
  "completion_tokens": 145,
  "total_tokens": 194,
  "prompt_tokens_details": {
    "cached_tokens": 0,
    "audio_tokens": 0
  },
  "completion_tokens_details": {
    "reasoning_tokens": 0,
    "audio_tokens": 0,
    "accepted_prediction_tokens": 0,
    "rejected_prediction_tokens": 0
  }
}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-88b40ae3-1660-4c6b-9733-7c76542c8640-0')

from langchain.chat_models import ChatOpenAI 
# 以下を追加
from langchain.prompts import PromptTemplate, ChatPromptTemplate

chat = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.1)

# 以下のようにテンプレートを内部に用意し
template = PromptTemplate.from_template(
    "{league}の試合はいつ始まりますか？"
)

# 文字列だけを渡すことで結果を得ることが出来る
user_prompt = template.format(league="Jリーグ")

chat.invoke(user_prompt)

# output
AIMessage(content='Jリーグの試合は通常、土曜日や日曜日に開催されます。試合の開始時間は、午後1時や午後3時など、各クラブや試合日によって異なります。詳細な試合スケジュールはJリーグ公式ウェブサイトや各クラブのウェブサイトで確認することができます。', additional_kwargs={}, response_metadata={'token_usage': <OpenAIObject at 0x113408710> JSON: {
  "prompt_tokens": 24,
  "completion_tokens": 120,
  "total_tokens": 144,
  "prompt_tokens_details": {
    "cached_tokens": 0,
    "audio_tokens": 0
  },
  "completion_tokens_details": {
    "reasoning_tokens": 0,
    "audio_tokens": 0,
    "accepted_prediction_tokens": 0,
    "rejected_prediction_tokens": 0
  }
}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-45772b17-574e-4a6b-9dc5-44d7cb42ed46-0')

from langchain.chat_models import ChatOpenAI 
from langchain.prompts import PromptTemplate, ChatPromptTemplate
from langchain.schema import HumanMessage, AIMessage, SystemMessage

chat = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.1)

chat_template = ChatPromptTemplate.from_messages([
    ("system", "あなたは {specialist}の専門家です"),
    ("ai", "こんにちは{name}さん"),
    ("user", "{league}の試合はいつ始まりますか？"),
])

chat_prompt = chat_template.format_messages(specialist="サッカー", name="金", league="Jリーグ")

chat.invoke(chat_prompt)

from langchain.chat_models import ChatOpenAI 
from langchain.prompts import ChatPromptTemplate

chat = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.1)

chat_template = ChatPromptTemplate.from_messages([
    ("system", "あなたは Jリーグの専門家です"),
    ("user", "{team}の試合はいつ始まりますか？"),
])

# チャットテンプレートとモデルを組み合わせて Chain を作成
# 1. chat_template: プロンプトテンプレートからメッセージを生成
# 2. chat: 生成されたメッセージを使ってAIモデルが応答
chat_chain = chat_template | chat

from langchain.chat_models import ChatOpenAI 
from langchain.prompts import ChatPromptTemplate

chat = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.1)

# chat テンプレートを作成
chat_template = ChatPromptTemplate.from_messages([
    ("system", "あなたは Jリーグの専門家です"),
    ("user", "{team}の試合はいつ始まりますか？"),
])

# chat Chain を作成
chat_chain = chat_template | chat

# team テンプレートを作成
team_template = ChatPromptTemplate.from_messages([
    ("system", "あなたはJリーグ専門家で、Jリーグチームの試合日程について詳しいです。もしわからない場合は、「わからない」と言ってください。"),
    ("user", "{schedule}の試合で最も早い試合を教えてください"),
])

# team Chain を作成
team_chain = team_template | chat

# 複数の Chain を組み合わせる
final_chat_chain = {"schedule":chat_chain} | team_chain

# チーム名を指定して情報を取得
final_chat_chain.invoke({
    "team": "神戸"
})

from langchain.chat_models import ChatOpenAI
from langchain.prompts.few_shot import FewShotChatMessagePromptTemplate
from langchain.prompts import ChatMessagePromptTemplate, ChatPromptTemplate

chat = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.1)

# # Few-Shot Learning 用のサンプルデータを定義
# 商品情報の形式を例示として設定
examples = [
   {
       "product": "wine 冷蔵庫",
       "answer": """
       wine 冷蔵庫
       詳細: wineを保存するための冷蔵庫です。
       平均値段: 30000円
       """,
   }
]

# サンプルデータ用のプロンプトテンプレートを作成
# ユーザーの質問と期待する応答形式を定義
example_prompt = ChatPromptTemplate.from_messages(
   [
       ("user", "{product}について知りたい。"),
       ("system", "{answer}"),
   ]
)

# Few-Shot プロンプトの作成
# サンプルデータとプロンプトテンプレートを組み合わせる
example_prompt = FewShotChatMessagePromptTemplate(
   example_prompt=example_prompt,
   examples=examples,
)

# 最終的なプロンプトテンプレートの作成
# システムロール設定、Few-Shot プロンプト、ユーザー入力を組み合わせる
last_prompt = ChatPromptTemplate.from_messages(
   [
       ("system", "あなたは家電商品全問がです。短く答えてください。"), # 役割の設定
       example_prompt, # Few-Shot の例を含める
       ("user", "{product}について知りたい"), # 実際の質問
   ]
)

# chain の作成と実行
chain = last_prompt | chat

chain.invoke({"product": "冷蔵庫"})

# output
AIMessage(content='冷蔵庫\n詳細: 食品や飲料を冷やして保存するための家電製品です。\n平均値段: 50000円')

from langchain.prompts.few_shot import FewShotChatMessagePromptTemplate
from langchain.prompts import load_prompt

chat = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.1)


# 外部ファイルからプロンプトテンプレートを読み込み
prompt = load_prompt("./prompt.yaml")

# テンプレートに変数を適用
prompt.format(league="Jリーグ")

# prompt.yaml
_type: "prompt"
template: "{league}のチームを教えてください。"
input_variables: ["league"]

// prompt.json
{
  "_type": "prompt",
  "template": "{league}のチームを教えてください。",
  "input_variables": ["league"]
}

from langchain.chat_models import ChatOpenAI
from langchain.globals import set_llm_cache
from langchain.cache import InMemoryCache

chat = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.1)

set_llm_cache(InMemoryCache())

chat.invoke("Jリーグのチームを教えて")

from langchain.memory import ConversationSummaryBufferMemory
from langchain.chat_models import ChatOpenAI
from langchain.schema.runnable import RunnablePassthrough
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder

chat_llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.1)

# 会話履歴を管理するメモリオブジェクトの作成
memory = ConversationSummaryBufferMemory(
    llm=chat_llm, # ここには ChatOpenAI インスタンスを設定
    max_token_limit=10, # token limit を設定(保持する最大トークン数)
    return_messages=True, # True:メッセージ形式で返す
)

# プロンプトテンプレートの設定
# MessagesPlaceholder について：
# - 会話履歴を配置する位置を指定するための特別なマーカー
# - メモリに保存された過去の会話が自動的にこの位置に展開されます
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "あなたは user をアシストする AI です。"),
         
        MessagesPlaceholder(variable_name="history"),
        ("user", "{question}"),
    ]
)


# memory.load_memory_variables({}) は保存された会話履歴を辞書形式で返す。
# ["history"]で会話履歴のみを抽出。
def memory_load(_):
    return memory.load_memory_variables({})["history"]

# chain の構成
# 1. RunnablePassthrough.assign(history=memory_load): 
#    memory_load 関数から会話履歴を取得し、historyキーに割り当て
# 2. prompt: 会話履歴とユーザーの質問を含むプロンプトを生成
# 3. chat_llm: 生成されたプロンプトを使用してAIの応答を生成
chain = RunnablePassthrough.assign(history=memory_load) | prompt | chat_llm

# チェーンを実行し、結果をメモリに保存する関数
def process_chain(question):
    result = chain.invoke({"question": question})
    # 現在の会話内容をメモリに保存
    memory.save_context(
        {"input": question},
        {"output": result.content},
    )
    print(result)

process_chain("私わきむたろうです。")

# output
content='はじめまして、わきむたろうさん。何かお手伝いできることはありますか？'

process_chain("私は誰ですか？")

# output
content='あなたはきむたろうさんですね。何かお手伝いできることがありますか？'

from langchain.memory import ConversationSummaryBufferMemory
from langchain.chat_models import ChatOpenAI
from langchain.schema.runnable import RunnablePassthrough
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.storage import LocalFileStore
from langchain.document_loaders import UnstructuredFileLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings, CacheBackedEmbeddings
from langchain.vectorstores import FAISS

chat_llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.1)

# 文書の分割（Splitting）設定
# 長い文書を小さな部分（チャンク）に分割します
#
# - chunk_size: 各チャンクのサイズ（200文字）
#   - 文書を200文字ごとに区切ります
#   - 例：400文字の文書は2つのチャンクに分割されます
#
# - chunk_overlap: チャンク間の重複部分（100文字）
#   - 前のチャンクの最後の100文字を次のチャンクの先頭に含めます
#   - これにより文脈が途切れることを防ぎます
#
# 分割例：
# 元の文書：「あいうえお かきくけこ さしすせそ たちつてと...」（400文字）
# chunk 1：「あいうえお かきくけこ...」（200文字）
# chunk 2：「けこ さしすせそ...」（前のチャンクと100文字重複）
text_chunker = CharacterTextSplitter.from_tiktoken_encoder(
    separator="\n",
    chunk_size=200,
    chunk_overlap=100,
)

# embeding の キャッシュを保存するローカルディレクトリの設定
#
# キャッシュとは？
# - エンベディング（テキストの数値変換）結果を保存する仕組み
# - 同じテキストの変換を何度も行わないようにする
#
# 動作の流れ：
# 1. 初回実行時：
#    テキスト → OpenAI API 呼び出し → embeding 取得 → .cache フォルダに保存
#
# 2. 2回目以降：
#    テキスト → .cache フォルダをチェック → 既にある場合はそれを使用 (ない場合はAPIを呼び出し
#
# メリット：
# - OpenAI API の呼び出し回数を減らせる（コスト削減）
# - 処理速度が向上する
cache_dir = LocalFileStore("./.cache/")

# ドキュメント(テキストファイル)の読み込み
loader = UnstructuredFileLoader("./files/test_document.txt")

# 読み込んだドキュメントを分割
splited_docs = loader.load_and_split(text_splitter=text_chunker)

# Vector 化 （Embedding）
# OpenAI の Embedding モデルを初期化
embeddings = OpenAIEmbeddings()

# Embedding 処理結果をキャッシュして API 呼び出しを最小限にsする
cached_embeddings = CacheBackedEmbeddings.from_bytes_store(embeddings, cache_dir)

## FAISS を使用して文書の vector を保存し検索可能にする
vectorstore = FAISS.from_documents(splited_docs, cached_embeddings)

# 検索用の retriver を作成
# ご参考: https://python.langchain.com/docs/concepts/retrievers/
retriver = vectorstore.as_retriever()

# プロンプトテンプレートの設定
# - system: AIの役割と応答方法を定義
# - user: ユーザーの質問を受け取る部分
prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "あなたは日本に詳しいアシスタントです。以下のコンテキストのみを使用して質問に答えてください。答えがわからない場合は、「わかりません」と答えてください。決して適当に答えないでください。\n\n{context}",
        ),
        ("user", "{question}"),
    ]
)

# chain の構成と実行フロー
# 1. 入力の準備：
#    - context: retriver が関連文書を検索
#    - question: RunnablePassthrough() でユーザーの質問をそのまま転送
#
# 2. プロンプトの生成：
#    - 検索された文書（context）と質問を組み合わせる
#    - 例：「context：○○○○\n質問：利根川はどこに流れていますか？」
#
# 3. 最終応答の生成：
#    - chat_llmが組み合わされたプロンプトを基に回答を生成
chain = (
    {
        "context": retriver,
        "question": RunnablePassthrough(),
    }
    | prompt
    | chat_llm
)

# チェーンの実行
# 1. chain.invoke から質問を受け取る
# 2. 関連文書を検索
# 3. プロンプトを生成
# 4. 回答を生成
chain.invoke("利根川はどこに流れていますか？")

import streamlit as st

st.title("Home")

(env) [~/langChain-gpt]$ streamlit run Home.py 

import streamlit as st

# main タイトルを設定
st.title("Home")

# Sidebar を作成 
# 以下のように書くと、Sidebar がすぐ表示される
# st.sidebar.title("Navigation")

# with を使うと、with block 中にある　widget のみ sidebar を表示できる
with st.sidebar:
    st.title("Side Navigation")
    page = st.radio("Choice", ["Home", "A-GPT", "B-Gemini"])

/Root
  |-- .streamlit
  |     |-- secrets.toml
  ├── app.py
  ├── pages
      ├── test_gpt.py

import streamlit as st
import time

# メインタイトルを設定
st.title("Test GPT Chatbot")

# session_stat について：
# Streamlit の特徴：
# - ユーザーの操作（入力など）があるたびに、スクリプト全体が再実行される
# - そのため、通常の変数では値を保持できない
# - session_state を使うことで、再実行しても値を保持できる
if "messages" not in st.session_state:
    # messages キーを初期化
    # - チャット履歴を保存するための空リストを作成
    # - この履歴は、ブラウザのセッションが続く限り保持される
    st.session_state["messages"] = []

# メッセージを表示と保存をする関数
def post_message(message, role, save=True):
    # role に応じてメッセージを表示
    # - role: "user" または "ai"
    with st.chat_message(role):
        st.write(message)
        
     # save=True の場合、メッセージを session_state に保存
    if save:
        st.session_state["messages"].append({"message": message, "role": role})

# 保存された全メッセージを表示
# - session_state から履歴を取得して表示
# - save=False で表示のみ行い、重複保存を防ぐ
for message in st.session_state["messages"]:
    post_message(
        message["message"],
        message["role"],
        save=False,
    )


# chat_input: 
# - メッセージを送信する widget
# - ユーザーがメッセージを入力できるUIを表示
message = st.chat_input("メッセージを送信 ")

# メッセージが入力された場合の処理
if message:
    # ユーザーメッセージを表示・保存
    post_message(message, "user")
    # 応答待ち時間を演出
    time.sleep(3)
    # AIの応答を表示・保存
    post_message(f"あなたのメッセージ: {message}", "ai")

    # サイドバーに session_state の内容を表示
    # - デバッグ用：現在の状態を確認できる
    with st.sidebar:
        st.write(st.session_state)

from langchain.chat_models import ChatOpenAI

# main タイトルを設定
st.title("Test GPT Chatbot")

chat_llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.1)


"""
reate_document_retriever():
ファイルからテキストを抽出し、検索可能な形式に変換するための関数
    
    処理内容：
    1. ファイル読み込み
    2. テキスト分割
    3. ベクトル化
    4. 検索システム作成
    
    Args:
        file: アップロードされたファイル
    Returns:
        retriever: 文書検索用の retriever
"""
# @st.cache_data: 同じファイルの場合、処理結果をキャッシュして再利用
# show_spinner: 処理中に表示されるローディングメッセージ
@st.cache_data(show_spinner="embeding..")
def create_document_retriever(file):
    # ファイルの読み込みと保存
    # - アップロードされたファイルの内容を読み込む
    file_read_content = file.read()

    # キャッシュ用のファイルパスを設定
    # .cache/files/ディレクトリにファイルを保存
    cache_file_path =  f"./.cache/files/{file.name}"

    # ファイルをキャッシュディレクトリに保存
    with open(cache_file_path, "wb") as f:
        f.write(file_read_content)
    
    # embeding のキャッシュディレクトリを設定
    cache_dir = LocalFileStore(f"./.cache/embeddings/{file.name}")
    
    # ファイルのテキスト抽出
    # - UnstructuredFileLoader を使用してファイルからテキストを抽出
    loader = UnstructuredFileLoader(cache_file_path)

    # テキストの分割設定
    # - separator: 改行で分割
    # - chunk_size: 各チャンクの最大サイズ（200トークン）
    # - chunk_overlap: チャンク間の重複サイズ（100トークン）
    text_chunker = CharacterTextSplitter.from_tiktoken_encoder(
    separator="\n",
    chunk_size=200,
    chunk_overlap=100,
    )

    # テキストを分割
    docs = loader.load_and_split(text_splitter=text_chunker)
    
    # embeding の設定
    # - OpenAIのエンベディングモデルを初期化
    openai_embeddings = OpenAIEmbeddings()

    # キャッシュを使用する embedding 設定
    # - 同じテキストの場合、既存の embedding を再利用
    cached_embeddings = CacheBackedEmbeddings.from_bytes_store(openai_embeddings, cache_dir)

    # vectorstore の作成
    # FAISSを使用してベクトルデータベースを作成
    vectorstore = FAISS.from_documents(docs, cached_embeddings)

    # 検索用リトリーバーの作成
    # vctorstore から類似文書を検索するための retriever を作成
    retriever = vectorstore.as_retriever()
    return retriever

# ...省略

# メッセージを表示と保存をする関数
def post_message(message, role, save=True):
    # role に合わせてメッセージを表示
    with st.chat_message(role):
        st.write(message)
        
    # save=True でメッセージを session_state 保存する
    if save:
        st.session_state["messages"].append({"message": message, "role": role})

# 保存された全メッセージを表示
def show_message_history():
    # session_state から履歴を取得して表示
    # save=False で表示のみ行い、重複保存を防ぐ
    for message in st.session_state["messages"]:
        post_message(
            message["message"],
            message["role"],
            save=False,
        )

# リトリーバーから取得した文書（docs）の内容（page_content）を改行（\n）で区切って連結する関数
def join_docs(docs):
    return "\n".join(document.page_content for document in docs)

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "あなたは日本に詳しいアシスタントです。以下のコンテキストのみを使用して質問に答えてください。答えがわからない場合は、「わかりません」と答えてください。決して適当に答えないでください。\n\n{context}",
        ),
        ("user", "{question}"),
    ]
)

with st.sidebar:
    file = st.file_uploader(
        "次の形式のファイルをアップロードしてください。.txt .pdf or .docx ",
        type=["pdf", "txt", "docx"],
    )

if file:
     # create_document_retriever でファイルを処理し、検索可能な形式に変換
    retriever = create_document_retriever(file)

    # 準備完了メッセージを表示（履歴には保存しない）
    post_message("準備できました！", "ai", save=False)

    # これまでのメッセージ履歴を表示
    show_message_history()

    # ユーザーがドキュメントに関する質問を入力できる widget を表示
    message = st.chat_input("アップロードしたドキュメントに関する質問を入力してください。")
    
    # ユーザーが質問を入力した場合の処理
    if message:
        # ユーザーの質問をチャット履歴に追加
        post_message(message, "user")

        # 質問応答 chain
        chain = (
            {
                "context": retriever | RunnableLambda(join_docs),
                "question": RunnablePassthrough(),
            }
            | prompt
            | chat_llm
        )
        # チェーンを実行して回答を生成
        response = chain.invoke(message)

        post_message(response.content, "ai")

else:
    st.session_state["messages"] = []

import streamlit as st
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.document_loaders import UnstructuredFileLoader
from langchain.embeddings import CacheBackedEmbeddings, OpenAIEmbeddings
from langchain.schema.runnable import RunnableLambda, RunnablePassthrough
from langchain.storage import LocalFileStore
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores.faiss import FAISS


# main タイトルを設定
st.title("Test GPT Chatbot")

chat_llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.1)

# ファイルからテキストを抽出し、検索可能な形式に変換するための関数
@st.cache_data(show_spinner="embeding..")
def create_document_retriever(file):
    # ファイルの読み込みと保存
    # - アップロードされたファイルの内容を読み込む
    file_read_content = file.read()

    # キャッシュ用のファイルパスを設定
    # .cache/files/ディレクトリにファイルを保存
    cache_file_path =  f"./.cache/files/{file.name}"

    # ファイルをキャッシュディレクトリに保存
    with open(cache_file_path, "wb") as f:
        f.write(file_read_content)
    
    # embeding のキャッシュディレクトリを設定
    cache_dir = LocalFileStore(f"./.cache/embeddings/{file.name}")
    
    # ファイルのテキスト抽出
    # - UnstructuredFileLoader を使用してファイルからテキストを抽出
    loader = UnstructuredFileLoader(cache_file_path)

    # テキストの分割設定
    text_chunker = CharacterTextSplitter.from_tiktoken_encoder(
    separator="\n",
    chunk_size=200,
    chunk_overlap=100,
    )

    # テキストを分割
    docs = loader.load_and_split(text_splitter=text_chunker)
    
    # embeding の設定
    # - OpenAIのエンベディングモデルを初期化
    openai_embeddings = OpenAIEmbeddings()

    # キャッシュを使用する embedding 設定
    # - 同じテキストの場合、既存の embedding を再利用
    cached_embeddings = CacheBackedEmbeddings.from_bytes_store(openai_embeddings, cache_dir)

    # vectorstore の作成
    # FAISSを使用してベクトルデータベースを作成
    vectorstore = FAISS.from_documents(docs, cached_embeddings)

     # 検索用リトリーバーの作成
    # vctorstore から類似文書を検索するための retriever を作成
    retriever = vectorstore.as_retriever()
    return retriever
  

# session_state : 
# streamlit はコードが実行されるたびに、全コードーが再実装されるため、
# session_state を使ってメッセージを保持する
if "messages" not in st.session_state:
    # messages キーでメッセージを保存する
    # 初期は空のリスト
    st.session_state["messages"] = []

# メッセージを表示と保存をする関数
def post_message(message, role, save=True):
    # role に合わせてメッセージを表示
    with st.chat_message(role):
        st.write(message)
        
    # save=True でメッセージを session_state 保存する
    if save:
        st.session_state["messages"].append({"message": message, "role": role})

# 保存された全メッセージを表示
def show_message_history():
    for message in st.session_state["messages"]:
        post_message(
            message["message"],
            message["role"],
            save=False,
        )

# リトリーバーから取得した文書（docs）の内容（page_content）を改行（\n）で区切って連結する関数
def join_docs(docs):
    return "\n".join(document.page_content for document in docs)

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "あなたは日本に詳しいアシスタントです。以下のコンテキストのみを使用して質問に答えてください。答えがわからない場合は、「わかりません」と答えてください。決して適当に答えないでください。\n\n{context}",
        ),
        ("user", "{question}"),
    ]
)

with st.sidebar:
    file = st.file_uploader(
        "次の形式のファイルをアップロードしてください。.txt .pdf or .docx ",
        type=["pdf", "txt", "docx"],
    )

if file:
    # create_document_retrieverでファイルを処理し、検索可能な形式に変換
    retriever = create_document_retriever(file)
    
    # 準備完了メッセージを表示（履歴には保存しない）
    post_message("準備できました！", "ai", save=False)

    # これまでのメッセージ履歴を表示
    show_message_history()

    # ユーザーがドキュメントに関する質問を入力
    message = st.chat_input("アップロードしたドキュメントに関する質問を入力してください。")
    
     # ユーザーが質問を入力した場合の処理
    if message:
        post_message(message, "user")
        chain = (
            {
                "context": retriever | RunnableLambda(join_docs),
                "question": RunnablePassthrough(),
            }
            | prompt
            | chat_llm
        )
        response = chain.invoke(message)
        post_message(response.content, "ai")

else:
    st.session_state["messages"] = []

利根川は大水上山を水源として関東地方を北から東へ流れ、太平洋に注ぐ河川。河川法に基づく国土交通省政令により1965年（昭和40年）に指定された一級河川・利根川水系の本流である。
「坂東太郎」の異名を持つ。
河川の規模としては日本最大級の規模を持ち、東京都を始めとした首都圏の水源として日本の経済活動上重要な役割を有する、日本を代表する河川の一つである。
群馬県利根郡みなかみ町にある三国山脈の一つ、大水上山（標高1,840メートル）にその源を発し、高崎市付近までは概ね南へ流れる