OUR + YOUR SPACE

[GPT][INVESTORGPT] Search Tool

으누아빠 — Mon, 20 May 2024 20:34:09 +0900

DuckDuckGoSearch를 이용하여 해당 search에서 데이터를 가져와 답변하도록 한다.

from typing import Type

from langchain.chat_models import ChatOpenAI

from langchain.tools import BaseTool

from pydantic import BaseModel,Field

from langchain.agents import initialize_agent, AgentType

from langchain.utilities import DuckDuckGoSearchAPIWrapper

llm = ChatOpenAI(

temperature=0.1,

)

class StockMarketSymbolSearchToolArgsSchema(BaseModel):

query: str = Field(description="The query you will search for.Example query: Stock Market Symbol for Apple Company")

class StockMarketSymbolSearchTool(BaseTool):

name = "StockMarketSymbolSearchTool"

description = """

Use this tool to find the stock market symbol for a company.

It takes a query as an argument.

Example query: Stock Market Symbol for Apple Company

"""

args_schem: Type[StockMarketSymbolSearchToolArgsSchema] = StockMarketSymbolSearchToolArgsSchema

def _run(self, query):

ddg = DuckDuckGoSearchAPIWrapper()

return ddg.run(query)

agent = initialize_agent(

llm=llm,

verbose=True,

agent=AgentType.OPENAI_FUNCTIONS,

handle_parsing_erros=True,

tools=[

StockMarketSymbolSearchTool(),

)

prompt = "Give me information on Cloudflare's stock and help me analyze if it's a potential good investment. Also tell me what symbol does the stock have."

agent.invoke(prompt)

[결과]

> Entering new AgentExecutor chain... Invoking: `StockMarketSymbolSearchTool` with `Cloudflare` Read the latest posts from Cloudflare's official blog, covering topics such as security, DNS, email, AI, developer tools, and more. Learn about Cloudflare's features, innovations, acquisitions, and events from the source. Following its initial announcement in September 2022, Cloudflare Calls is now in open beta and available in your Cloudflare Dashboard.Cloudflare Calls lets developers build real-time audio/video apps using WebRTC, and it abstracts away the complexity by turning the Cloudflare network into a singular SFU.In this post, we dig into how we make this possible. Cloudflare's Year in Review revealed that in 2023 alone, there was a 25% increase in global traffic, with no signs of slowing. This growth underscores the dependency on Internet services to facilitate and underpin vital systems and tasks such as supporting global digital economies, enabling the operations of healthcare networks, maintaining ... Press Releases 2024. Press Releases. 2024. US Department of Treasury, Pacific Northwest National Laboratory, and Cloudflare Partner to Share Early Warning Threat Intelligence for Financial Institutions. May 09, 2024. Cloudflare Announces Unified Risk Posture to Provide Comprehensive and Continuous Risk Management at Scale—for Free. May 07, 2024. Finally, because Cloudflare also operates a CDN, websites that are already on Cloudflare will be given a "hot-path," and will load faster. We at Cloudflare are always striving to bring more privacy options to the open Internet, and we are excited to provide more private and secure browsing to Edge users.The stock market symbol for Cloudflare is NET. As for analyzing if Cloudflare is a potential good investment, it's important to consider various factors such as the company's financial performance, growth potential, competitive landscape, and market trends. Here are some points to consider: 1. **Financial Performance**: Look at Cloudflare's revenue growth, profitability, and cash flow. Analyze their quarterly and annual financial reports to understand their financial health. 2. **Growth Potential**: Evaluate Cloudflare's market position, product offerings, and expansion plans. Consider if they are in a growing industry and have the potential for future growth. 3. **Competitive Landscape**: Assess Cloudflare's competitors and how they differentiate themselves in the market. Look at their market share and competitive advantages. 4. **Market Trends**: Consider industry trends, technological advancements, and regulatory changes that could impact Cloudflare's business. 5. **Risk Factors**: Identify any potential risks that could affect Cloudflare's stock performance, such as cybersecurity threats, regulatory challenges, or economic downturns. It's recommended to consult with a financial advisor or do further research to make an informed decision on whether Cloudflare is a good investment for you. > Finished chain.

{'input': "Give me information on Cloudflare's stock and help me analyze if it's a potential good investment. Also tell me what symbol does the stock have.", 'output': "The stock market symbol for Cloudflare is NET. \n\nAs for analyzing if Cloudflare is a potential good investment, it's important to consider various factors such as the company's financial performance, growth potential, competitive landscape, and market trends. Here are some points to consider:\n\n1. **Financial Performance**: Look at Cloudflare's revenue growth, profitability, and cash flow. Analyze their quarterly and annual financial reports to understand their financial health.\n\n2. **Growth Potential**: Evaluate Cloudflare's market position, product offerings, and expansion plans. Consider if they are in a growing industry and have the potential for future growth.\n\n3. **Competitive Landscape**: Assess Cloudflare's competitors and how they differentiate themselves in the market. Look at their market share and competitive advantages.\n\n4. **Market Trends**: Consider industry trends, technological advancements, and regulatory changes that could impact Cloudflare's business.\n\n5. **Risk Factors**: Identify any potential risks that could affect Cloudflare's stock performance, such as cybersecurity threats, regulatory challenges, or economic downturns.\n\nIt's recommended to consult with a financial advisor or do further research to make an informed decision on whether Cloudflare is a good investment for you."}

[GPT][INVESTORGPT] OpenAI Functions Agent

으누아빠 — Mon, 20 May 2024 19:58:59 +0900

OPENAI_FUNCTIONS

이경우 데이터의 형태를 지정하지 않으면 오류를 발생함

InvalidRequestError: Invalid 'functions[0].name': string does not match pattern. Expected a string that matches the pattern '^[a-zA-Z0-9_-]+$'.

from typing import Type

from langchain.chat_models import ChatOpenAI

from langchain.tools import BaseTool

from pydantic import BaseModel,Field

from langchain.agents import initialize_agent, AgentType

llm = ChatOpenAI(

temperature=0.1,

)

class CalculatorToolArgsSchemea(BaseModel):

a:float = Field(description="The First number")

b:float = Field(description="The second number")

class CalculatorTool(BaseTool):

name = "SumsCalculator"

description = """

Use this to perform sums of two numbers.

The first and second arguments should be numbers.

Only receives two arguments.

"""

args_schema: Type[CalculatorToolArgsSchemea] = CalculatorToolArgsSchemea

def _run(self, a, b):

return a + b

agent = initialize_agent(

llm=llm,

verbose=True,

agent=AgentType.OPENAI_FUNCTIONS,

handle_parsing_erros=True,

tools=[

CalculatorTool(),

)

prompt = "Tell me Total Cost of $355.39 + $924.87 + $721.2 + $1940.29 + $573.63 + $65.72 + $35.00 + $552.00 + $76.16 + $29.12"

agent.invoke(prompt)

pydantic

데이터 유효성 검사는 데이터가 각 속성에 대해 정의한 일련의 규칙, 스키마 또는 제약 조건을 준수하도록 하는 프로세스
데이터 유효성 검사를 통과하면 코드가 예상했던 정확한 방식으로 데이터를 수집하고 반환

데이터 유효성 검사는 잘못된 사용자 입력과 같은 문제로 인해 발생하는 예기치 않은 오류를 방지
그런 의미에서 sanitization process라고도 함

Field
모델 스키마 또는 복잡한 유효성 검사를 위해 필드에 대한 추가 정보를 제공하는 데 사용

[GPT][INVESTORGPT] Zero-shot ReAct Agent

으누아빠 — Mon, 20 May 2024 15:15:12 +0900

from langchain.chat_models import ChatOpenAI

from langchain.tools import Tool

from langchain.agents import initialize_agent, AgentType

llm = ChatOpenAI(

temperature=0.1,

)

def plus(inputs):

a,b = inputs.split(",")

return float(a) + float(b)

agent = initialize_agent(

llm=llm,

verbose=True,

agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,

handle_parsing_erros=True,

tools=[

Tool.from_function(

func=plus,

name="Sum Calculator",

description="Use this to perform sums of two numbers. This tool take two arguments, both should be numbers. till finish. Use this tool by sending a pair of number separated by a comma. \n Example: 2,3",

)

prompt = "Tell me Total Cost of $355.39 + $924.87 + $721.2 + $1940.29 + $573.63 + $65.72 + $35.00 + $552.00 + $76.16 + $29.12"

#llm.invoke(prompt)

agent.invoke(prompt)

Zero-shot ReAct

작업과 도구 설명을 보고 사용할 도구를 결정

ReAct는 Reasoning + Acting으로 Yao et al. (2022)의 논문에 소개된 개념

Reasoning은 생각(Chain-of-Thought, COT), Acting은 외부 도구 실행을 의미

필요한 작업에 따라 정하면 되는데, Zero-shot ReAct가 가장 기본이 되는 Agent

전달 받는값은 1개로 제한되며, 이를 분리하여 사용한다.

[GPT][INVESTORGPT] Agent

으누아빠 — Mon, 20 May 2024 14:17:55 +0900

> Entering new AgentExecutor chain... Thought: I can use the Sum Calculator tool to find the total cost of all the given amounts. Action: ``` { "action": "Sum Calculator", "action_input": {"a": 355.39, "b": 924.87} } ``` Observation: 1280.26 Thought:``` { "action": "Sum Calculator", "action_input": {"a": 1280.26, "b": 721.2} } ``` Observation: 2001.46 Thought:``` { "action": "Sum Calculator", "action_input": {"a": 2001.46, "b": 1940.29} } ``` Observation: 3941.75 Thought:``` { "action": "Sum Calculator", "action_input": {"a": 3941.75, "b": 573.63} } ``` Observation: 4515.38 Thought:``` { "action": "Sum Calculator", "action_input": {"a": 4515.38, "b": 65.72} } ``` Observation: 4581.1 Thought:``` { "action": "Sum Calculator", "action_input": {"a": 4581.1, "b": 35.00} } ``` Observation: 4616.1 Thought:``` { "action": "Sum Calculator", "action_input": {"a": 4616.1, "b": 552.00} } ``` Observation: 5168.1 Thought:``` { "action": "Sum Calculator", "action_input": {"a": 5168.1, "b": 76.16} } ``` Observation: 5244.26 Thought:``` { "action": "Sum Calculator", "action_input": {"a": 5244.26, "b": 29.12} }

{'input': 'Tell me Total Cost of $355.39 + $924.87 + $721.2 + $1940.29 + $573.63 + $65.72 + $35.00 + $552.00 + $76.16 + $29.12', 'output': 'I have calculated the total cost of all the given amounts. The final answer is $5273.38.'}

from langchain.chat_models import ChatOpenAI

from langchain.tools import StructuredTool

from langchain.agents import initialize_agent, AgentType

llm = ChatOpenAI(

temperature=0.1,

)

def plus(a, b):

return a + b

agent = initialize_agent(

llm=llm,

verbose=True,

agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,

tools=[

StructuredTool.from_function(

func=plus,

name="Sum Calculator",

description="Use this to perform sums of two numbers. This tool take two arguments, both should be numbers. till finish.",

)

prompt = "Tell me Total Cost of $355.39 + $924.87 + $721.2 + $1940.29 + $573.63 + $65.72 + $35.00 + $552.00 + $76.16 + $29.12"

#llm.invoke(prompt)

agent.invoke(prompt)

llm 은 연산을 목적으로 만들어진것이 아니기 때문에 잘못된 정보를 호출하게됨. 이를 막기 위해서 agent를 이용하여

정상적인 답이 나오도록 수정할수 있음

agent

에이전트의 핵심 아이디어는 언어 모델을 사용하여 수행할 일련의 작업을 선택

체인에서는 일련의 작업이 코드로 하드코딩됨

에이전트에서 언어 모델은 수행할 작업과 순서를 결정하는 추론 엔진으로 사용됩니다.

즉 agent는 체인이 사용할 도구를 선택해서 지원할 수 있도록하며 LLM을 사용하여 원하는 작업을 수행하는 절차를 정의 하며, 이때 어떠한 도구를 사용하여 목적을 달성할 것인지를 스스로 판단하여 사용
사용자는 구현된 tool이 어떠한 동작을 하는지 정확하게 description 해주기만 하면 알아서 가져다가 쓰도록 되어 있음

StructuredTool
에이전트가 수행할 수 있는 작업을 지정해주는 기능을 함

func - 툴로 등록할 함수 이름을 지정,
name - 툴의 이름,
description - 툴에 대한 설명을 추가

AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION
이 에이전트는 여러 입력이 있는 도구를 호출

[GPT][MEETINGGPT] 최종 예제

으누아빠 — Tue, 14 May 2024 12:49:39 +0900

from langchain.storage import LocalFileStore

import streamlit as st

import subprocess

import math

from pydub import AudioSegment

import glob

import openai

import os

from langchain.chat_models import ChatOpenAI

from langchain.prompts import ChatPromptTemplate

from langchain.document_loaders import TextLoader

from langchain.text_splitter import RecursiveCharacterTextSplitter

from langchain.schema import StrOutputParser

from langchain.vectorstores.faiss import FAISS

from langchain.embeddings import CacheBackedEmbeddings, OpenAIEmbeddings

llm = ChatOpenAI(

temperature=0.1,

)

has_transcript = os.path.exists("./.cache/meeting.txt")

splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(

chunk_size=800,

chunk_overlap=100,

)

@st.cache_data()

def embed_file(file_path):

cache_dir = LocalFileStore(f"./.cache/embeddings/{file.name}")

splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(

chunk_size=800,

chunk_overlap=100,

)

loader = TextLoader(file_path, encoding="utf-8")

docs = loader.load_and_split(text_splitter=splitter)

embeddings = OpenAIEmbeddings()

cached_embeddings = CacheBackedEmbeddings.from_bytes_store(embeddings, cache_dir)

vectorstore = FAISS.from_documents(docs, cached_embeddings)

retriever = vectorstore.as_retriever()

return retriever

@st.cache_data()

def transcribe_chunks(chunk_folder, destination):

if has_transcript:

return

files = glob.glob(f"{chunk_folder}/*.mp3")

files.sort()

for file in files:

with open(file, "rb") as audio_file, open(destination, "a", encoding="utf-8") as text_file:

transcript = openai.Audio.transcribe(

"whisper-1",

audio_file,

)

text_file.write(transcript["text"])

@st.cache_data()

def extract_audio_from_video(video_path):

if has_transcript:

return

if video.name.endswith("mp3"):

return

audio_path = video_path.replace("mp4", "mp3")

command = [

"ffmpeg",

"-y",

"-i",

video_path,

"-vn",

audio_path,

]

subprocess.run(command)

@st.cache_data()

def cut_audio_in_chunks(audio_path, chunk_size, chunks_folder):

if has_transcript:

return

track = AudioSegment.from_mp3(audio_path)

chunk_len = chunk_size * 60 * 1000

chunks = math.ceil(len(track) / chunk_len)

for i in range(chunks):

start_time = i * chunk_len

end_time = (i + 1) * chunk_len

chunk = track[start_time:end_time]

chunk.export(

f"./{chunks_folder}/chunk_{i}.mp3",

format="mp3",

)

st.set_page_config(

page_title="MeetingGPT",

page_icon=" ",

)

st.markdown(

"""

# MeetingGPT

Welcome to MeetingGPT, upload a video and I will give you a transcript, a summary and a chat bot to ask any questions about it.

Get started by uploading a video file in the sidebar.

"""

)

with st.sidebar:

video = st.file_uploader(

"Video",

type=["mp4", "avi", "mkv", "mov", "mp3"],

)

if video:

chunks_folder = "./.cache/chunks"

with st.status("Loading video...") as status:

video_content = video.read()

if video.name.endswith("mp3"):

video_path = f"./.cache/{video.name}"

audio_path = f"./.cache/{video.name}"

transcript_path = audio_path.replace("mp3", "txt")

else:

video_path = f"./.cache/{video.name}"

audio_path = video_path.replace("mp4", "mp3")

transcript_path = video_path.replace("mp4", "txt")

with open(video_path, "wb") as f:

f.write(video_content)

status.update(label="Extracting audio...")

extract_audio_from_video(video_path)

status.update(label="Cutting audio segments...")

cut_audio_in_chunks(audio_path, 1, chunks_folder)

status.update(label="Transcribing audio...")

transcribe_chunks(chunks_folder, transcript_path)

transcript_tab, summary_tab, qa_tab = st.tabs(

[

"Transcript",

"Summary",

"Q&A",

]

)

with transcript_tab:

with open(transcript_path, "r",encoding='UTF-8') as file:

st.write(file.read())

with summary_tab:

start = st.button("Generate summary")

if start:

loader = TextLoader(transcript_path, encoding="utf-8")

docs = loader.load_and_split(text_splitter=splitter)

first_summary_prompt = ChatPromptTemplate.from_template(

"""

Write a concise summary of the following:

"{text}"

CONCISE SUMMARY:

"""

)

first_summary_chain = first_summary_prompt | llm | StrOutputParser()

summary = first_summary_chain.invoke(

{"text": docs[0].page_content},

)

refine_prompt = ChatPromptTemplate.from_template(

"""

Your job is to produce a final summary.

We have provided an existing summary up to a certain point: {existing_summary}

We have the opportunity to refine the existing summary (only if needed) with some more context below.

------------

{context}

------------

Given the new context, refine the original summary.

If the context isn't useful, RETURN the original summary.

Please summarize it in Korean

"""

)

refine_chain = refine_prompt | llm | StrOutputParser()

with st.status("Summarizing...") as status:

for i, doc in enumerate(docs[1:]):

status.update(label=f"Processing document {i+1}/{len(docs)-1} ")

summary = refine_chain.invoke(

{

"existing_summary": summary,

"context": doc.page_content,

}

)

st.write(summary)

with qa_tab:

retriever = embed_file(transcript_path)

docs = retriever.invoke("do they talk about marcus aurelius?")

st.write(docs)

[GPT][MEETINGGPT] Refine Chain

으누아빠 — Tue, 14 May 2024 12:47:02 +0900

refine[문서 분할-병합 요약]
입력 문서를 순회하며 반복적으로 답변을 업데이트하여 응답을 구성합니다.
각 문서에 대해, 모든 비문서 입력, 현재 문서, 그리고 최신 중간 답변을 LLM chain에 전달하여 새로운 답변을 얻습니다.

with summary_tab:

start = st.button("Generate summary")

if start:

loader = TextLoader(transcript_path, encoding="utf-8")

docs = loader.load_and_split(text_splitter=splitter)

first_summary_prompt = ChatPromptTemplate.from_template(

"""

Write a concise summary of the following:

"{text}"

CONCISE SUMMARY:

"""

)

first_summary_chain = first_summary_prompt | llm | StrOutputParser()

summary = first_summary_chain.invoke(

{"text": docs[0].page_content},

)

refine_prompt = ChatPromptTemplate.from_template(

"""

Your job is to produce a final summary.

We have provided an existing summary up to a certain point: {existing_summary}

We have the opportunity to refine the existing summary (only if needed) with some more context below.

------------

{context}

------------

Given the new context, refine the original summary.

If the context isn't useful, RETURN the original summary.

Please summarize it in Korean

"""

)

refine_chain = refine_prompt | llm | StrOutputParser()

with st.status("Summarizing...") as status:

for i, doc in enumerate(docs[1:]):

status.update(label=f"Processing document {i+1}/{len(docs)-1} ")

summary = refine_chain.invoke(

{

"existing_summary": summary,

"context": doc.page_content,

}

)

st.write(summary)

[GPT][MEETINGGPT] Whisper Transcript

으누아빠 — Tue, 14 May 2024 12:39:59 +0900

whisper란?
openai에서 공개한 인공지능 모델로 음성을 텍스트로 변환할 수 있는 기술

def transcribe_chunks(chunk_folder, destination):

if has_transcript:

return

files = glob.glob(f"{chunk_folder}/*.mp3")

files.sort()

for file in files:

with open(file, "rb") as audio_file, open(destination, "a", encoding="utf-8") as text_file:

transcript = openai.Audio.transcribe(

"whisper-1",

audio_file,

)

text_file.write(transcript["text"])

glob.glob()
특정한 패턴이나 확장자를 가진 파일들의 경로나 이름이 필요할 때가 있음

glob 모듈의 glob 함수는 사용자가 제시한 조건에 맞는 파일명을 리스트 형식으로 반환

단, 조건에 정규식을 사용할 수 없으며 엑셀 등에서도 사용할 수 있는 '*'와 '?'같은 와일드카드만을 지원

[GPT][MEETINGGPT] Cutting The Audio

으누아빠 — Tue, 14 May 2024 12:25:02 +0900

pydub

pydub은 Python으로 오디오 처리 작업을 수행할 수 있게 하는 유용한 라이브러리 중 하나

이 라이브러리를 사용하면 오디오 파일의 생성, 변환, 조작, 재생 속도 변경, 오디오 형식 간 변환 등 다양한 작업을 수행할 수 있음

pydub에서 AudioSegment는 오디오 데이터를 나타내는 핵심 객체입

이 객체는 여러 오디오 형식(예: MP3, WAV)의 오디오 데이터를 처리하고 다양한 작업을 수행하는 데 사용

설치
pip install pydub

from pydub import AudioSegment

def cut_audio_in_chunks(audio_path, chunk_size, chunks_folder):

if has_transcript:

return

track = AudioSegment.from_mp3(audio_path)

chunk_len = chunk_size * 60 * 1000

chunks = math.ceil(len(track) / chunk_len)

for i in range(chunks):

start_time = i * chunk_len

end_time = (i + 1) * chunk_len

chunk = track[start_time:end_time]

chunk.export(

f"./{chunks_folder}/chunk_{i}.mp3",

format="mp3",

)

AudioSegment.export(파일명, 포멧)

변환된 데이터를 내보내는 메서드

[예제]

from pydub import AudioSegment

# AudioSegment 객체 생성

audio = AudioSegment.from_file("input_audio.mp3")

# 내보낼 파일 형식과 경로 지정

output_format = "wav"

output_path = "output_audio.wav"

# 파일로 내보내기

audio.export(output_path, format=output_format)

[GPT][MEETINGGPT] Audio Extraction

으누아빠 — Tue, 14 May 2024 11:54:25 +0900

1. ffmpeg 를 설치 해야함

https://ffmpeg.org/ 에서 다운로드를 받음

에서 windows builds from gyan.dev 클릭

원하는 파일 다운로드 여기서는 ffmpeg-release-essentials.zip 다운로드 후 c:\Program Files\ffmpeg에 복사

시스템 환경 변수에 C:\Program Files\ffmpeg\bin 추가

정상적으로 기동하는 지 확인해야함

def extract_audio_from_video(video_path):

if has_transcript:

return

if video.name.endswith("mp3"):

return

audio_path = video_path.replace("mp4", "mp3")

command = [

"ffmpeg",

"-y",

"-i",

video_path,

"-vn",

audio_path,

]

subprocess.run(command)

[ffmpeg 옵션 정보]

-y 묻지 않고 출력 파일을 덮어씀
-i 지정된 파일을 읽는 옵션
-vn 비디오 스트림을 무시하고 오디오 스트림만 처리

subprocess.run

현재 실행되고 있는 프로세스안에서 또 다른 프로세스를 시작하거나 데이터를 주고 받고자 하는 목적

[GPT][SITEGPT] Map Re Rank Chain

으누아빠 — Mon, 13 May 2024 18:06:56 +0900

from langchain.document_loaders import SitemapLoader

from langchain.schema.runnable import RunnableLambda, RunnablePassthrough

from langchain.text_splitter import RecursiveCharacterTextSplitter

from langchain.vectorstores.faiss import FAISS

from langchain.embeddings import OpenAIEmbeddings

from langchain.chat_models import ChatOpenAI

from langchain.prompts import ChatPromptTemplate

from bs4 import BeautifulSoup

import streamlit as st

import asyncio

import sys

llm = ChatOpenAI(

temperature=0.1,

)

answers_prompt = ChatPromptTemplate.from_template(

"""

Using ONLY the following context answer the user's question. If you can't just say you don't know, don't make anything up.

Then, give a score to the answer between 0 and 5.

If the answer answers the user question the score should be high, else it should be low.

Make sure to always include the answer's score even if it's 0.

Context: {context}

Examples:

Question: How far away is the moon?

Answer: The moon is 384,400 km away.

Score: 5

Question: How far away is the sun?

Answer: I don't know

Score: 0

Your turn!

Question: {question}

"""

)

def get_answers(inputs):

docs = inputs["docs"]

question = inputs["question"]

answers_chain = answers_prompt | llm

print(docs)

return {

"question": question,

"answers": [

{

"answer": answers_chain.invoke(

{"question": question, "context": doc.page_content}

).content,

"source": doc.metadata["source"],

}

for doc in docs

}

def choose_answer(inputs):

answers = inputs["answers"]

question = inputs["question"]

choose_chain = choose_prompt | llm

condensed = "\n\n".join(

f"{answer['answer']}\nSource:{answer['source']}\n"

for answer in answers

)

return choose_chain.invoke(

{

"question": question,

"answers": condensed,

}

)

choose_prompt = ChatPromptTemplate.from_messages(

[

(

"system",

"""

Use ONLY the following pre-existing answers to answer the user's question.

Use the answers that have the highest score (more helpful) and favor the most recent ones.

Cite sources and return the sources of the answers as they are, do not change them.

Answers: {answers}

""",

("human", "{question}"),

]

)

def parse_page(soup: BeautifulSoup):

header = soup.find("header")

footer = soup.find("footer")

if header:

header.decompose()

if footer:

footer.decompose()

return (

str(soup.get_text())

.replace("\n", " ")

.replace("\xa0", " ")

.replace("CloseSearch Submit Blog", "")

)

@st.cache_data(show_spinner="Loading website...")

def load_website(url):

splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(

chunk_size=1000,

chunk_overlap=200,

)

loader = SitemapLoader(

url,

parsing_function=parse_page,

)

loader.requests_per_second = 2

docs = loader.load_and_split(text_splitter=splitter)

vector_store = FAISS.from_documents(docs, OpenAIEmbeddings())

return vector_store.as_retriever()

st.set_page_config(

page_title="SiteGPT",

page_icon=" ️",

)

st.markdown(

"""

# SiteGPT

Ask questions about the content of a website.

Start by writing the URL of the website on the sidebar.

"""

)

if 'win32' in sys.platform:

# Windows specific event-loop policy & cmd

asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())

#asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())

cmds = [['C:/Windows/system32/HOSTNAME.EXE']]

else:

# Unix default event-loop policy & cmds

cmds = [

['du', '-sh', '/Users/fredrik/Desktop'],

['du', '-sh', '/Users/fredrik'],

['du', '-sh', '/Users/fredrik/Pictures']

]

with st.sidebar:

url = st.text_input(

"Write down a URL",

placeholder="https://example.com",

)

if url:

if ".xml" not in url:

with st.sidebar:

st.error("Please write down a Sitemap URL.")

else:

retriever = load_website(url)

query = st.text_input("Ask a question to the website.")

if query:

chain = (

{

"docs": retriever,

"question": RunnablePassthrough(),

}

| RunnableLambda(get_answers)

| RunnableLambda(choose_answer)

)

result = chain.invoke(query)

st.markdown(result.content.replace("$", "\$"))

Map re-rank

문서들마다 각각의 답변을 만들어 내고, 이에 점수를 부여
가장 높은 점수를 받은 답변을 최종 답변으로 채택함

문서가 구분되어 있고 높은 유사성을 요구할 때 유용

answers_prompt 의 내용을 확인하면 예시가 존재함