import os

# 環境変数からAPIキーを取得
#api_key = "sk_..."
api_key = os.getenv("OPENAI_API_KEY")

if api_key is None:
    raise ValueError("OPENAI_API_KEYが設定されていません。")
else:
    print("APIキーを取得しました。")

# ConversationBufferMemory クラスをインポート
from langchain.memory import ConversationBufferMemory

# ConversationBufferMemory のインスタンスを作成
# return_messages=True を指定することで、メモリからの出力が文字列ではなくメッセージオブジェクトのリストとして返されます。
memory = ConversationBufferMemory(return_messages=True)

# ユーザーからのメッセージをメモリに追加
memory.save_context({"input": "こんにちは"}, {"output": "こんにちは！今日はどのようにお手伝いできますか？"})

# AIからのメッセージをメモリに追加
memory.save_context({"input": "今日は天気がいいですね"}, {"output": "そうですね！晴れた日は気持ちが良いですね。"})

# 現在の会話履歴を取得
# return_messages=True の場合、メッセージオブジェクトのリストが返されます。
chat_history = memory.load_memory_variables({})

# 会話履歴を表示
for message in chat_history['history']:
    print(f"{message.type.capitalize()}: {message.content}")

Human: こんにちは
Ai: こんにちは！今日はどのようにお手伝いできますか？
Human: 今日は天気がいいですね
Ai: そうですね！晴れた日は気持ちが良いですね。

memory.chat_memory.add_user_message("hi!")
memory.chat_memory.add_ai_message("what's up?")

# 必要なモジュールをインポート
from langchain_openai import OpenAI
from langchain_core.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory

# 言語モデルの初期化（temperature=0で決定論的な応答を生成）
llm = OpenAI(temperature=0)

# プロンプトテンプレートを作成
# `chat_history` に過去の会話履歴が挿入される
template = """あなたは人間と会話をしている親切なチャットボットです。

これまでの会話:
{chat_history}

新しい人間からの質問: {question}
応答:"""

# PromptTemplateを作成し、指定したテンプレートを利用
prompt = PromptTemplate.from_template(template)

# ConversationBufferMemory を使用して会話履歴を保存
# memory_key="chat_history" はプロンプトの `{chat_history}` に対応
memory = ConversationBufferMemory(memory_key="chat_history")

# 会話の履歴を保存
memory.save_context(
    {"input": "田中さんはUiPath Studioの開発に詳しいです"},  # ユーザーの発言
    {"output": "よし、分かった"}  # AIの応答
)

# LLMChain を作成し、言語モデル・プロンプト・メモリを組み合わせる
conversation = LLMChain(
    llm=llm,  # 言語モデル
    prompt=prompt,  # プロンプトテンプレート
    verbose=True,  # 実行時の詳細情報を表示
    memory=memory  # 会話の履歴を管理
)

# `question` 変数のみ渡せばよい（`chat_history` はメモリが自動で補完）
response = conversation({"question": "田中さんの専門は何ですか、詳しく教えてください。"})

# 応答を表示
print(response)

> Entering new LLMChain chain...
Prompt after formatting:
あなたは人間と会話をしている親切なチャットボットです。

これまでの会話:
Human: 田中さんはUiPath Studioの開発に詳しいです
AI: よし、分かった

新しい人間からの質問: 田中さんの専門は何ですか、詳しく教えてください。
応答:

> Finished chain.
{'question': '田中さんの専門は何ですか、詳しく教えてください。',
 'chat_history': 'Human: 田中さんはUiPath Studioの開発に詳しいです\nAI: よし、分かった',
 'text': ' 田中さんの専門はUiPath Studioの開発です。彼はUiPath Studioを使用して、自動化されたプロセスを作成し、ビジネスプロセスの効率を向上させることができます。また、彼はプログラミング言語やデータベースの知識も豊富で、UiPath Studioをより効果的に活用することができます。'}

from langchain_openai import ChatOpenAI
from langchain_core.prompts import (
    ChatPromptTemplate,
    MessagesPlaceholder,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate,
)
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory


# 言語モデルの初期化
llm = ChatOpenAI()

# チャットプロンプトテンプレートの作成
prompt = ChatPromptTemplate(
    messages=[
        # システムメッセージ（AIの役割を定義）
        SystemMessagePromptTemplate.from_template(
            "あなたは人間と会話する親切なチャットボットです。"
        ),
        # `variable_name` は、メモリ内の変数と一致する必要があります。
        MessagesPlaceholder(variable_name="chat_history"),
        # 人間からの新しい質問
        HumanMessagePromptTemplate.from_template("{question}")
    ]
)

# `return_messages=True` を指定することで、MessagesPlaceholder に適合させる
# "chat_history" の変数名は MessagesPlaceholder の変数名と一致させる必要がある
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
memory.save_context({"input":"田中さんはUiPath Studioの開発に詳しいです"},{"output":"よし、分かった"})
# 会話チェーンの作成
conversation = LLMChain(
    llm=llm,
    prompt=prompt,
    verbose=True,
    memory=memory
)
conversation({"question": "田中さんの専門は何ですか、詳しく教えてください。"})

> Entering new LLMChain chain...
Prompt after formatting:
System: あなたは人間と会話する親切なチャットボットです。
Human: 田中さんはUiPath Studioの開発に詳しいです
AI: よし、分かった
Human: 田中さんの専門は何ですか、詳しく教えてください。

> Finished chain.
{'question': '田中さんの専門は何ですか、詳しく教えてください。',
 'chat_history': [HumanMessage(content='田中さんはUiPath Studioの開発に詳しいです', additional_kwargs={}, response_metadata={}),
  AIMessage(content='よし、分かった', additional_kwargs={}, response_metadata={}),
  HumanMessage(content='田中さんの専門は何ですか、詳しく教えてください。', additional_kwargs={}, response_metadata={}),
  AIMessage(content='田中さんは主にRPA（Robotic Process Automation）に関連する技術やツールに精通しています。具体的にはUiPath StudioというRPA開発ツールに詳しく、プロセスの自動化やワークフローの最適化において豊富な経験を持っています。また、プログラミングスキルやビジネスプロセスの理解にも優れており、顧客のニーズに合わせた効果的な自動化ソリューションを提供することが得意です。', additional_kwargs={}, response_metadata={})],
 'text': '田中さんは主にRPA（Robotic Process Automation）に関連する技術やツールに精通しています。具体的にはUiPath StudioというRPA開発ツールに詳しく、プロセスの自動化やワークフローの最適化において豊富な経験を持っています。また、プログラミングスキルやビジネスプロセスの理解にも優れており、顧客のニーズに合わせた効果的な自動化ソリューションを提供することが得意です。'}

# 必要なモジュールをインポート
from langchain.memory import ChatMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.memory import ConversationBufferMemory
from langchain.chains import LLMChain
from langchain_openai import ChatOpenAI

# メッセージ履歴の初期化（過去の会話を保持する）
history = ChatMessageHistory()

# ユーザーからのメッセージを追加（過去の会話を履歴に保存）
history.add_user_message("こんにちは！今日東京の天気が晴れていますね")

# AIからのメッセージを追加（AIの応答を履歴に保存）
history.add_ai_message("こんにちは！そうですね")

# チャットプロンプトテンプレートの作成
prompt = ChatPromptTemplate.from_messages([
    # 過去の会話履歴をプレースホルダーとして利用
    MessagesPlaceholder(variable_name="chat_history"),
    # ユーザーの新しい質問を受け取る
    ("human", "{input}")
])

# 会話履歴を管理するメモリを作成
memory = ConversationBufferMemory(
    chat_memory=history,  # `ChatMessageHistory` インスタンスを利用
    memory_key="chat_history",  # プロンプトの `chat_history` プレースホルダーと一致させる
    return_messages=True  # メッセージをオブジェクトのリストとして返す
)

# 言語モデルの初期化
llm = ChatOpenAI()

# 会話の流れを管理する LLMChain を作成
conversation = LLMChain(
    llm=llm,       # 言語モデル（ChatGPT）
    prompt=prompt, # プロンプトテンプレート（履歴 + 新しい質問）
    memory=memory, # メモリ（会話履歴の管理）
    verbose=True   # デバッグ情報を詳細に表示
)

# ユーザーの新しい質問を入力し、AIの応答を取得
response = conversation.predict(input="今日の東京の天気はどうですか？")

# AIの応答を表示
print(response)

> Entering new LLMChain chain...
Prompt after formatting:
Human: こんにちは！今日東京の天気が晴れていますね
AI: こんにちは！そうですね
Human: 今日の東京の天気はどうですか？

> Finished chain.
今日の東京の天気は晴れで、気温は20度ほどです。気持ちの良い天気ですね！

from langchain.memory import ConversationBufferWindowMemory

# 直近3件の会話だけを保持する
memory = ConversationBufferWindowMemory(k=3)

# ユーザーとAIの会話を保存
memory.chat_memory.add_user_message("こんにちは")
memory.chat_memory.add_ai_message("こんにちは！")
memory.chat_memory.add_user_message("天気はどうですか？")
memory.chat_memory.add_ai_message("晴れです。")
memory.chat_memory.add_user_message("気温は？")

# 会話履歴の取得
print(memory.chat_memory.messages)  

[HumanMessage(content='こんにちは', additional_kwargs={}, response_metadata={}), AIMessage(content='こんにちは！', additional_kwargs={}, response_metadata={}), HumanMessage(content='天気はどうですか？', additional_kwargs={}, response_metadata={}), AIMessage(content='晴れです。', additional_kwargs={}, response_metadata={}), HumanMessage(content='気温は？', additional_kwargs={}, response_metadata={})]

from langchain.memory import ConversationSummaryMemory
from langchain.llms import OpenAI

# メモリの作成（会話の要約機能を持つ）
memory = ConversationSummaryMemory(llm=OpenAI())

# ユーザーの入力とAIの応答を保存
memory.save_context({"input": "私は山田です"}, {"output": "よろしくお願いします"})
memory.save_context({"input": "旅行が好きです"}, {"output": "どこに行きましたか？"})

# まとめられた履歴を取得
print(memory.load_memory_variables({})["history"])

The human introduces themselves as Yamada and mentions their love for traveling. The AI responds by asking where they have traveled.

from langchain.memory import ConversationEntityMemory
from langchain.llms import OpenAI

# エンティティを記憶するメモリ
memory = ConversationEntityMemory(llm=OpenAI())

# 情報の保存
memory.save_context({"input": "私は佐藤です"}, {"output": "佐藤さん、こんにちは！"})
memory.save_context({"input": "私は東京に住んでいます"}, {"output": "東京のどこですか？"})

# 記憶されたエンティティの確認
memory.load_memory_variables({"input": '鈴木さんは神奈川県の横浜市の関内のららぽーと横浜に住んでいます。教師です'})

{'history': 'Human: 私は佐藤です\nAI: 佐藤さん、こんにちは！\nHuman: 私は東京に住んでいます\nAI: 東京のどこですか？',
 'entities': {'鈴木さん': '',
  '神奈川県': '',
  '横浜市': '',
  '関内': '',
  'ららぽーと横浜': '',
  '教師': ''}}

# 必要なライブラリをインポート
from langchain.chains import ConversationChain  # LangChain の会話管理クラス
from langchain_openai import ChatOpenAI  # OpenAI の GPT モデルを利用

import os  # 環境変数（APIキーの取得）用
from langchain.memory import ConversationBufferMemory  # 会話の履歴を保存するためのメモリ

# ChatGPT に対するリクエストを処理する関数
def get_chat_response(prompt, memory, openai_api_key):
    """
    ユーザーの入力を基に AI から応答を取得する関数。

    Parameters:
    - prompt (str): ユーザーの質問やメッセージ
    - memory (ConversationBufferMemory): 会話履歴を管理するオブジェクト
    - openai_api_key (str): OpenAI APIキー

    Returns:
    - response (str): AI からの応答メッセージ
    """

    # OpenAI の GPT モデル（gpt-3.5-turbo）を設定
    model = ChatOpenAI(model="gpt-3.5-turbo", openai_api_key=openai_api_key)

    # LangChain の会話チェーンを作成（会話履歴を含む）
    chain = ConversationChain(llm=model, memory=memory)

    # AI にプロンプトを送信し、応答を取得
    response = chain.invoke({"input": prompt})

    # 取得した応答を返す
    return response["response"]

# 会話の履歴を保持するメモリオブジェクトを作成
memory = ConversationBufferMemory(return_messages=True)

# 以下のコメントアウトされたコードを実行すると、ChatGPT との対話が可能になる
print(get_chat_response("ニュートンが提唱した有名な法則は？", memory, os.getenv("OPENAI_API_KEY")))
print(get_chat_response("私の前の質問は何？", memory, os.getenv("OPENAI_API_KEY")))

# 必要なライブラリをインポート
import streamlit as st  # Streamlit: Webアプリを作成するライブラリ
from langchain.memory import ConversationBufferMemory  # 会話の履歴を管理するためのメモリ
from utils import get_chat_response  # OpenAI の API を使って AI 応答を取得する関数

# アプリのタイトルを設定
st.title("💬 ChatGPT クローン")

# サイドバーの設定
with st.sidebar:
    # ユーザーが OpenAI API Key を入力する欄（パスワード形式で入力）
    openai_api_key = st.text_input("OpenAI API Key を入力してください：", type="password")
    # OpenAI API Key を取得するためのリンクを表示
    st.markdown("[OpenAI API Key を取得する](https://platform.openai.com/account/api-keys)")
    if st.button("会話履歴をクリア"):
        st.session_state["messages"] = [
            {"role": "ai", "content": "こんにちは、私はあなたのAIアシスタントです。何かお手伝いできますか？"}]

# セッションステートに会話履歴がない場合、新しく作成する
if "memory" not in st.session_state:
    # 会話履歴を保存するためのメモリを作成
    st.session_state["memory"] = ConversationBufferMemory(return_messages=True)

    # 初回メッセージとして AI アシスタントの挨拶を設定
    st.session_state["messages"] = [
        {"role": "ai", "content": "こんにちは、私はあなたのAIアシスタントです。何かお手伝いできますか？"}]

# これまでの会話履歴を順番に表示
for message in st.session_state["messages"]:
    # AI またはユーザーのメッセージを表示
    st.chat_message(message["role"]).write(message["content"])

# ユーザーが入力欄にメッセージを入力
prompt = st.chat_input()

# ユーザーがメッセージを入力した場合の処理
if prompt:
    # OpenAI API Key が未入力の場合はエラーを表示して処理を停止
    if not openai_api_key:
        st.info("OpenAI API Key を入力してください")
        st.stop()

    # ユーザーのメッセージを会話履歴に追加
    st.session_state["messages"].append({"role": "human", "content": prompt})
    # 入力したメッセージを画面に表示
    st.chat_message("human").write(prompt)

    # AI の応答を取得する処理（ローディングのスピナーを表示）
    with st.spinner("AIが考えています。しばらくお待ちください..."):
        response = get_chat_response(prompt, st.session_state["memory"], openai_api_key)

    # AI の応答を会話履歴に追加
    msg = {"role": "ai", "content": response}
    st.session_state["messages"].append(msg)
    # AI の応答を画面に表示
    st.chat_message("ai").write(response)