LangChainは実装してなんぼでしょ！書籍「ChatGPT/LangChainによるチャットシステム構築［実践］入門」から得た学び3選 〜 書籍とは違う実装してみた 〜

#%%
import streamlit as st 
import os 
from dotenv import load_dotenv
from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage
from langchain.agents import AgentType, initialize_agent, load_tools
from langchain.callbacks import StreamlitCallbackHandler
from langchain.memory import ConversationBufferMemory
from langchain.prompts import MessagesPlaceholder

load_dotenv()

# 1. AIエージェントの設定
def create_agent_chain():
    chat = ChatOpenAI(
        model_name = os.environ['OPENAI_API_MODEL'],
        temperature = os.environ['OPENAI_API_TEMPERATURE'],
        streaming = True
    )

    agent_kawrgs = {
        'extra_prompt_messages': [MessagesPlaceholder(variable_name='memory')],
    }

    memory = ConversationBufferMemory(memory_key = 'memory', return_messages=True)

    tools = load_tools(['ddg-search', 'wikipedia'])
    return initialize_agent(tools, chat, agent = AgentType.OPENAI_FUNCTIONS, agent_kwargs=agent_kawrgs, memory = memory)

if 'agent_chain' not in st.session_state:
    st.session_state.agent_chain = create_agent_chain()

# 2. チャットアプリのデザインの設定
st.title('langchain-streamlit-app')

if "messages" not in st.session_state:
    st.session_state.messages = []

for message in st.session_state.messages:
    with st.chat_message(message['role']):
        st.markdown(message['content'])

prompt = st.chat_input('What is up?')

# 3. チャットの応答ロジックの設定
if prompt:
    st.session_state.messages.append({'role': 'user', 'content': prompt})
    with st.chat_message('user'):
        st.markdown(prompt)
    with st.chat_message('assistant'):
        callback = StreamlitCallbackHandler(st.container())
        response = st.session_state.agent_chain.run(prompt, callbacks = [callback])
        st.markdown(response)

    st.session_state.messages.append({'role': 'assistant', 'content': response})
# %%

# この部分でAIエージェントが使うツールを指定しています
tools = load_tools(['ddg-search', 'wikipedia'])

my_data = {
   'basic_information': {
      'name': 'Aoki Kazuya',
      'sex':   'Man', 
      'birth': '1995-11-05',
      'country': 'Japan',
   },
   'change_information': {
      'job': 'Data Scientist', 
      'age': 29,
      'work_place': 'Tokyo',
      'live_place': 'Kanagawa' 
   }
}

weather = {
   'prefecture': 'Tokyo', 
   'city_name' : 'Shinagawa', 
   'date': '2025-01-07',
   'time': '12:00', 
   'weather': 'sunny', 
   'temperature': 23.4,
}

import json

from langchain.chat_models import ChatOpenAI
from langchain.chains import create_extraction_chain

schema = {
   'properties': {
      'prefecture': {'type': 'string'}, 
      'city_name' : {'type': 'string'}, 
      'date': {'type': 'string'},
      'time': {'type': 'string'}, 
      'weather': {'type': 'string'}, 
      'temperature': {'type': 'integer'},
   }, 
   'required': ['prefecture', 'date', 'time', 'weather', 'temperature']
}

search_result = """
...
天気予報 トップページ   2024年1月7日 12時 \t\t\t 天気: 東京 \t\t\t 23.5°C, 晴れ 
\n\n 天気: 神奈川 \t\t\t 24.2°C, 曇り
...
"""

chat = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
chain = create_extraction_chain(schema, chat)

people = chain.run(text)
print(json.dumps(people, indent=2))

weather = {
   'prefecture': 'Tokyo', 
   'date': '2025-01-07',
   'time': '12:00', 
   'weather': 'sunny', 
   'temperature': 23.5,
}

chain = LLMChain(prompt = prompt, llm = chat, output_parser = output_parser)

chain = prompt | llm | output_parser

import os 
from dotenv import load_dotenv
from slack_bolt import App
import time 
from typing import Any
import re
from langchain import hub
from add_document import initialize_vectorstore
from langchain.chains import create_retrieval_chain, create_history_aware_retriever
import concurrent.futures
from langchain_openai import ChatOpenAI
from slack_bolt.adapter.socket_mode import SocketModeHandler
from langchain.callbacks.base import BaseCallbackHandler
from langchain.schema import LLMResult
from langchain.memory import ConversationBufferWindowMemory
from langchain_core.output_parsers import StrOutputParser
from datetime import timedelta
from langchain.schema import HumanMessage, LLMResult, SystemMessage
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.messages import BaseMessage 
from langchain.chains import create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain
from pydantic import Field
from typing import Sequence
import openai
from langchain.chains import LLMChain
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder, HumanMessagePromptTemplate
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.runnables import RunnablePassthrough

load_dotenv()

model = os.environ['OPENAI_API_MODEL']
CHAT_UPDATE_INTERVAL_SEC = 1
SLACK_BOT_USER_ID = os.environ['SLACK_BOT_USER_ID']
openai.api_key = os.environ['OPENAI_API_KEY']

class LimitedChatMessageHistory(ChatMessageHistory):
    max_messages: int = Field(default = 10)

    def __init__(self, max_messages = 10):
        super().__init__()
        self.max_messages = max_messages

    def add_messages(self, messages: Sequence[BaseMessage]) -> None:
        super().add_messages(messages)
        self._limit_messages()

    def _limit_messages(self):
        if len(self.messages) > self.max_messages:
            self.messages = self.messages[-self.max_messages : ]

from langchain_core.chat_history import BaseChatMessageHistory

store = {}
memory = LimitedChatMessageHistory(max_messages = 5)

def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = memory
    return store[session_id]

class SlackStreamingCallbackHandler(BaseCallbackHandler):
    last_send_time = time.time()
    message = ""

    def __init__(self, channel, ts):
        self.channel = channel
        self.ts = ts 

    def on_llm_new_token(self, token: str, **kwargs) -> None:
        self.message += token

        now = time.time()
        if now - self.last_send_time > CHAT_UPDATE_INTERVAL_SEC:
            self.last_send_time = now
            app.client.chat_update(
                channel = self.channel, ts = self.ts, text = self.message
            )

    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> Any:
        app.client.chat_update(channel= self.channel, ts = self.ts, text = self.message)

app = App(token = os.environ['SLACK_BOT_TOKEN'],
          signing_secret = os.environ['SLACK_SIGNING_SECRET'],
          process_before_response= True)

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

def send_chat_request(memory, input_message: str):
    try: 
        prompt = hub.pull('langchain-ai/chat-langchain-rephrase')
        llm = ChatOpenAI(model_name = model)
        vectorstore = initialize_vectorstore()
        retriever = vectorstore.as_retriever()
        chat_retriever_chain = create_history_aware_retriever(
            llm ,retriever, prompt
        )
        response = chat_retriever_chain.invoke(
            {'input': input_message }
        )
        return response
    except Exception as e:
        return f"エラー発生: {e}"

def call_function_with_timeout(func, timeout_seconds, *args):
    with concurrent.futures.ThreadPoolExecutor() as executor:
        future = executor.submit(func, *args)
        try:
            response = future.result(timeout = timeout_seconds)
            return {'result': response}
        except concurrent.futures.TimeoutError:
            return {'error': "Function execution timed out"}
        
def remove_slack_id_from_text(text, slack_id):
    return text.replace(f"<@{slack_id}>", "")

def create_prompt():
    messages = [
        SystemMessage(content = "Assistant is a large language model trainied by OpenAI."),
        HumanMessagePromptTemplate.from_template('{human_input}')
    ]
    # prompt = PromptTemplate(input_variables=['history', 'human_input'], template=template)
    prompt = ChatPromptTemplate.from_messages(messages)
    
    return prompt
            
@app.event('message')
def handle_message_events(body):
    return None

@app.event('app_mention')
def handle_mention(event, say):
    input_message = event['text']
    thread_ts = event.get('thread_ts') or None
    channel = event['channel']
    user_id = event['user']

    prompt = create_prompt()

    input_message = remove_slack_id_from_text(input_message, SLACK_BOT_USER_ID)

    timeout_seconds = 2 * 60
    response = call_function_with_timeout(send_chat_request, timeout_seconds, memory, input_message)

    if "error" in response or response['result'] is None:
        reply_text = f'<@{user_id}>\nごめんなさい。現在サーバーの負荷が高いため処理できませんでした。時間をおいて再度質問してください。'
    else:
        reply_text = response['result']
        reply_text = f'<@{user_id}>\n{reply_text}'

    if thread_ts is not None:
        parent_thread_ts = event['thread_ts']
        say(blocks = [
            {
                'type': 'section',
                'text': {
                    'type': 'mrkdwn', 'text': reply_text
                }
            },
            {'type': 'divider'},
            {'type': 'context', 'elements': [{'type': 'mrkdwn', 'text': "OpenAI APIで生成される情報は不正確または不適切な場合がありますが、AOKIの見解を述べるものではありません。"}]}
        ],text = reply_text, thread_ts = parent_thread_ts, channel = channel)
    else:
        response = app.client.conversations_replies(channel= channel, ts = event['ts'])
        thread_ts = response['messages'][0]['ts']
        say(blocks = [
            {
                'type': 'section',
                'text': {
                    'type': 'mrkdwn', 'text': reply_text
                }
            },
            {'type': 'divider'},
            {'type': 'context', 'elements': [{'type': 'mrkdwn', 'text': "OpenAI APIで生成される情報は不正確または不適切な場合がありますが、AOKIの見解を述べるものではありません。"}]}
        ],
            text = reply_text, thread_ts = thread_ts, channel = channel)

if __name__ == '__main__':
    SocketModeHandler(app, os.environ['SLACK_APP_TOKEN']).start()

# %%
import logging 
import os 
import sys 
from uuid import uuid4
from langchain_community.document_loaders import PyPDFLoader

from dotenv import load_dotenv
from langchain_community.document_loaders import UnstructuredPDFLoader
from langchain_community.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
import faiss
from langchain_community.docstore.in_memory import InMemoryDocstore
from langchain_community.vectorstores import FAISS

load_dotenv()

logging.basicConfig(
    format = "%(asctime)s [%(levelname)s] %(message)s", level = logging.INFO
)


logger = logging.getLogger(__name__)

def initialize_vectorstore():
    embeddings = OpenAIEmbeddings()
    index = faiss.IndexFlat(len(embeddings.embed_query('hello world')))
    vector_store = FAISS(
        embedding_function=embeddings, 
        index = index, 
        docstore=InMemoryDocstore(),
        index_to_docstore_id={}
    )

    file_path = 'jdlasg2023_report.pdf'
    loader = PyPDFLoader(file_path)
    raw_docs = loader.load()
    print(raw_docs)
    logger.info("Loaded %d documents", len(raw_docs))

    text_splitter = CharacterTextSplitter(chunk_size = 300, chunk_overlap = 30, separator = '')
    docs = text_splitter.split_documents(raw_docs)
    logger.info("Split %d documents", len(docs))

    vector_store.add_documents(docs, ids = [str(uuid4()) for _ in range(len(docs))])
    return vector_store


# %%