pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

from langchain_nvidia_ai_endpoints import ChatNVIDIA
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain.schema.runnable import RunnableLambda
from langchain.schema.runnable.passthrough import RunnableAssign
from langchain_core.runnables import RunnableBranch
from langchain_core.runnables import RunnablePassthrough
 
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
import os
import base64
import matplotlib.pyplot as plt
import numpy as np

os.environ["NVIDIA_API_KEY"] = "nvapi-xxx"

import requests
from bs4 import BeautifulSoup
from urllib.parse import urljoin, urlparse
// 这里可以修改你想爬取的最大连接数量，如果笔记本性能比较差，不建议太大值
MAX_PAGES = 500
def crawl_website(start_url, max_pages=100):
    start_host = urlparse(start_url).netloc  # Extract the host part of the start URL
    visited = set()
    queue = [start_url]
    results = [start_url]
    with open('links.txt', 'w') as file:  # Open file for writing
        while queue and len(results) < max_pages:
            current_url = queue.pop(0)
            if current_url in visited:
                continue
            try:
                response = requests.get(current_url, timeout=10)
                if response.status_code == 200:
                    visited.add(current_url)
                    results.append(current_url)
                    print('add url@' +  current_url)
                    file.write(current_url + '\n')  # Write the current URL to the file
                    soup = BeautifulSoup(response.text, 'html.parser')
                    # Find all links and add to the queue
                    for link in soup.find_all('a', href=True):
                        absolute_link = urljoin(current_url, link['href'])
                        if absolute_link not in visited and absolute_link not in results and urlparse(absolute_link).netloc == start_host:
                            queue.append(absolute_link)
            except requests.RequestException:
                continue
    return results
def read_links_file(filepath='links.txt'):
    with open(filepath, 'r') as file:
        return [line.strip() for line in file]

import os
# 替换下面的 URL 为网站首页
start_url = "https://www.abc.com"
if os.path.exists('links.txt'):
    found_pages = read_links_file()
    print("Read links from file")
else:
    print("File not found. Starting crawl...")
    found_pages = crawl_website(start_url)
    print("Crawled pages:")
# 去重
found_pages = set(url.strip('/') for url in found_pages)
found_pages = list(found_pages)
print(found_pages)

import re
from typing import List, Union
import base64
import requests
from bs4 import BeautifulSoup
def html_document_loader(url: Union[str, bytes]) -> str:
    """
    Loads the HTML content of a document from a given URL and return it's content.
    Args:
        url: The URL of the document.
    Returns:
        The content of the document.
    Raises:
        Exception: If there is an error while making the HTTP request.
    """
    try:
        response = requests.get(url)
        content_type = response.headers.get('Content-Type', '')
        if 'image' in content_type:
            image_b64 = base64.b64encode(response.content).decode('utf-8')
            chart_reading = ChatNVIDIA(model="microsoft/phi-3-vision-128k-instruct")
            result = chart_reading.invoke( f'生成下图的中文描述, : <img src="data:image/png;base64,{image_b64}" />')
            return result.content
        html_content = response.text
    except Exception as e:
        print(f"Failed to load {url} due to exception {e}")
        return ""
    try:
        # 创建Beautiful Soup对象用来解析html
        soup = BeautifulSoup(html_content, "html.parser")
        # 删除脚本和样式标签
        for script in soup(["script", "style"]):
            script.extract()
        # 从 HTML 文档中获取纯文本
        text = soup.get_text()
        # 去除空格换行符
        text = re.sub("\s+", " ", text).strip()
        return text
    except Exception as e:
        print(f"Exception {e} while loading document")
        return ""

from langchain.text_splitter import RecursiveCharacterTextSplitter
# text_splitter = CharacterTextSplitter(chunk_size=400, separator=" ")
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=400,
    chunk_overlap=0,
    length_function=len,
)
def create_embeddings(embedding_path: str = "./embed"):
    embedding_path = "./embed"
    print(f"Storing embeddings to {embedding_path}")
    urls =  found_pages
    for url in urls:
        print('load url@' + url)
        document = html_document_loader(url)
        texts = text_splitter.create_documents([document])
        try:
            index_docs(url, text_splitter, texts, embedding_path)
        except Exception as e:
            print("Generated embedding fail")
            print(e)
        else:
            print("Generated embedding successfully")

from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings
from langchain.vectorstores import FAISS
def clean_text(text):
    # 移除无用的换行符和多余空格
    return text.replace("\\n", " ").strip()
embeddings = NVIDIAEmbeddings(model="NV-Embed-QA")
def index_docs(url: Union[str, bytes], splitter, documents: List[str], dest_embed_dir) -> None:
    """
    Split the document into chunks and create embeddings for the document
    Args:
        url: Source url for the document.
        splitter: Splitter used to split the document
        documents: list of documents whose embeddings needs to be created
        dest_embed_dir: destination directory for embeddings
    Returns:
        None
    """
    docs = []
    metadatas = []
    for document in documents:
        texts = splitter.split_text(document.page_content)
        docs.extend(texts)
        metadatas.extend([{"source":url}] * len(texts))
    
    docs = [clean_text(text) for text in docs]
    
    try:
        # Attempt to load an existing index if it exists
        store = FAISS.load_local(folder_path=dest_embed_dir, embeddings=embeddings, allow_dangerous_deserialization=True)
    except:
        # If the index doesn't exist, create a new one
        store = FAISS.from_texts(docs, embeddings, metadatas=metadatas)
    else:
        store.add_texts(docs, metadatas=metadatas)
    store.save_local(folder_path=dest_embed_dir)

# 只需要执行一次的
create_embeddings()

from langchain.chains.conversational_retrieval.prompts import CONDENSE_QUESTION_PROMPT, QA_PROMPT
from langchain.chains import ConversationalRetrievalChain, LLMChain
from langchain.chains.question_answering import load_qa_chain
llm = ChatNVIDIA(model="meta/llama-3.1-405b-instruct", temperature=0.8, max_tokens=1000, top_p=1.0)
embedding_path = "embed/"
docsearch = FAISS.load_local(folder_path=embedding_path, embeddings=embeddings, allow_dangerous_deserialization=True)
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
question_generator = CONDENSE_QUESTION_PROMPT | llm
chat = ChatNVIDIA(model="meta/llama-3.1-405b-instruct", temperature=0.1, max_tokens=1000, top_p=1.0)
doc_chain = load_qa_chain(chat , chain_type="stuff", prompt=QA_PROMPT)
retriever = docsearch.as_retriever()
# helper function 用于Debug
def print_and_return(x):
    print(x)
    return x
def welcome( user_input, ):
    doc_chain = load_qa_chain(chat , chain_type="stuff", prompt=QA_PROMPT)
    prompt = ChatPromptTemplate.from_messages(
        [
            (
                "system",
                "Answer solely based on the following context:\n<Documents>\n{context}\n</Documents>, 禁止透漏你是从文档中获取的信息,必须以一名公司接待人员的口吻回答.必须用中文回答",
            ),
            ("user", "{question}"),
        ]
    )
    
    chain = (
        {"context": retriever, "question": RunnablePassthrough()}
        | RunnableLambda(print_and_return)
        | prompt
        | RunnableLambda(print_and_return)
        | llm
        | StrOutputParser()
    )
    rag_result = chain.invoke(user_input)
    return rag_result

# answer = welcome('介绍下公司')
# print(answer)

import pyttsx3
import os
def tts_function(text):
    # 使用 pyttsx3 将文本转为语音并保存为音频文件
    engine = pyttsx3.init()
    audio_file = "output.mp3"
    engine.save_to_file(text, audio_file)
    engine.runAndWait()
    return audio_file
def play_tts(text):
    audio_path = tts_function(text)
    return audio_path

# path = play_tts(answer)
# print(path)

def audioRole(user_input,):
    llmAnswer = welcome(user_input)
    return play_tts(llmAnswer)

import gradio as gr
import whisper
# 加载 Whisper 模型
model = whisper.load_model("small")
def transcribe_audio(audio):
    # 使用 Whisper 模型进行语音转文字
    result = model.transcribe(audio)
    return result["text"]

def audioOrText(source,user_input):
    print(user_input,source)
    if source is not None:
        user_input = transcribe_audio(source)
    print(user_input)
    if len(user_input):
       return audioRole(user_input)

import gradio as gr
multi_modal_chart_agent = gr.Interface(fn=audioOrText,
                    inputs=[gr.Audio(sources=['microphone'], type="filepath"), 'text'], #gr.Image(label="Upload image", type="filepath"),
                    outputs=['audio'],
                    title="Multi Modal chat agent",
                    description="Multi Modal chat agent",
                    allow_flagging="never")
multi_modal_chart_agent.launch(debug=True, share=False, show_api=False, server_port=5000, server_name="0.0.0.0")