from langchain.chains.llm import LLMChain
from langchain_community.llms import OpenAI
from langchain_core.prompts import PromptTemplate

# 创建一个 GPT-3.5 的 LLMChain
def create_py_chain() -> LLMChain:
    prompt_template = """
    你是一名 Python 工程师，擅长解答关于 Python 编程的问题。
    下面是需要你来回答的问题：
    {input}
    """
    prompt = PromptTemplate(
        template=prompt_template,
        input_variables=["input"],
    )
    llm = OpenAI()
    return LLMChain(llm=llm, prompt=prompt, verbose=True)

# 创建一个 GPT-4 的 LLMChain
def create_go_chain() -> LLMChain:
    prompt_template = """
    你是一名 Golang 工程师，擅长解答关于 Golang 编程的问题。
    下面是需要你来回答的问题：
    {input}
    """
    prompt = PromptTemplate(
        template=prompt_template,
        input_variables=["input"],
    )
    llm = OpenAI()
    return LLMChain(llm=llm, prompt=prompt, verbose=True)

# 创建两个 LLMChain
chain_map = {
    "Python": create_py_chain(),
    "Golang": create_go_chain(),
}

from langchain.chains.router.llm_router import LLMRouterChain, RouterOutputParser
from langchain.chains.router.multi_prompt_prompt import MULTI_PROMPT_ROUTER_TEMPLATE

destinations = [
    "Python: 适合回答关于 Python 编程的问题",
    "Golang: 适合回答关于 Golang 编程的问题",
]
router_template = MULTI_PROMPT_ROUTER_TEMPLATE.format(destinations="\n".join(destinations))
router_prompt = PromptTemplate(
    template=router_template,
    input_variables=["input"],
    output_parser=RouterOutputParser(),
)

router_chain = LLMRouterChain.from_llm(
    llm=OpenAI(),
    prompt=router_prompt,
    verbose=True
)

default_chain = ConversationChain(llm=OpenAI(), output_key="text", verbose=True)

from langchain.chains.router import MultiPromptChain
chain = MultiPromptChain(
    router_chain=router_chain,
    default_chain=default_chain,
    destination_chains=chain_map,
    verbose=True
)

print(chain.invoke({"input": "如何在 Python 中定义一个函数？"}))

print(router_prompt.format(input="如何在 Python 中定义一个函数？"))

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.5, max_tokens=200)

summarizing_prompt_template = """
输出为 JSON 格式，包含字段 content、summary。

总结以下文本为一个 20 字以内的句子:
---
{content}
"""
prompt = PromptTemplate.from_template(summarizing_prompt_template)

summarizing_chain = prompt | llm | StrOutputParser()

print(summarizing_chain.invoke({"content": "这是一个测试。"}))

from langchain.output_parsers import StructuredOutputParser, ResponseSchema
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model_name="gpt-3.5-turbo",
    temperature=0.5,
    max_tokens=200
)

response_schemas = [
    ResponseSchema(name="content", description="The original content"),
    ResponseSchema(name="summary", description="The summary of the content"),
]
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
format_instructions = output_parser.get_format_instructions()

summarizing_prompt_template = """
{format_instructions}

总结以下文本为一个 20 字以内的句子:
---
{content}
"""
prompt = PromptTemplate.from_template(summarizing_prompt_template, partial_variables={'format_instructions': format_instructions})

summarizing_chain = prompt | llm | output_parser

print(summarizing_chain.invoke({"content": "这是一个测试。"}))

from langchain.output_parsers import StructuredOutputParser, ResponseSchema
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model_name="gpt-3.5-turbo",
    temperature=0.5,
    max_tokens=200
)

response_schemas = [
    ResponseSchema(name="content", description="The original content"),
    ResponseSchema(name="summary", description="The summary of the content"),
]

output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
format_instructions = output_parser.get_format_instructions()

summarizing_prompt_template = """
{format_instructions}

总结以下文本为一个 20 字以内的句子:
---
{content}
"""
prompt = PromptTemplate.from_template(
    summarizing_prompt_template,
    partial_variables={'format_instructions': format_instructions}
)

summarizing_chain = prompt | llm | output_parser

print(summarizing_chain.invoke({"content": "这是一个测试。"}))

from langchain import PromptTemplate

template = """你是业务咨询顾问。你给一个销售{product}的电商公司，起一个好的名字。"""

prompt = PromptTemplate.from_template(template)

print(prompt.format(product="手机"))

from langchain import PromptTemplate
prompt = PromptTemplate(
    template="""你是业务咨询顾问。你给一个销售{product}的电商公司，起一个好的名字。""",
    input_variables=['product']
)
print(prompt.format(product="电脑"))

from openai import OpenAI

client = OpenAI()

client.chat.completions.create(
    model='gpt-3.5-turbo',
    messages=[
        {'role': 'system', 'content': 'You are a helpful assistant.'},
        {'role': 'user', 'content': 'What is the capital of France?'},
        {'role': 'assistant', 'content': 'The capital of France is Paris.'}
    ]
)

from langchain.prompts import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate
)
template = "你是一位专业顾问，负责为专注于{product}的公司起名"
system_message_prompt = SystemMessagePromptTemplate.from_template(template)
human_template = "公司主打产品是{product_detail}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)

prompt_template = ChatPromptTemplate.from_messages([
    system_message_prompt,
    human_message_prompt
])

prompt = prompt_template.format_prompt(product="鲜花装饰", product_detail="创新的鲜花设计").to_messages()

from langchain.chat_models import ChatOpenAI

chat = ChatOpenAI()
result = chat(prompt)

print(result)

samples = [
    {
        "flower_type": "玫瑰",
        "occasion": "爱情",
        "ad_copy": "玫瑰，浪漫的象征，是你向心爱的人表达爱意的最佳选择。"
    },
    {
        "flower_type": "康乃馨",
        "occasion": "母亲节",
        "ad_copy": "康乃馨代表着母爱的纯洁与伟大，是母亲节赠送给母亲的完美礼物。"
    },
    {
        "flower_type": "百合",
        "occasion": "庆祝",
        "ad_copy": "百合象征着纯洁与高雅，是你庆祝特殊时刻的理想选择。"
    },
    {
        "flower_type": "向日葵",
        "occasion": "鼓励",
        "ad_copy": "向日葵代表着阳光与希望，是你鼓励朋友或家人的最佳礼物。"
    }
]

from langchain.prompts.prompt import PromptTemplate
template = "鲜花类型：{flower_type}\n适用场合：{occasion}\n广告文案：{ad_copy}"
prompt_sample = PromptTemplate(
    input_variables=["flower_type", "occasion", "ad_copy"],
    template=template
)
print(prompt_sample.format_prompt(**samples[0]))

from langchain.prompts.few_shot import FewShotPromptTemplate
prompt = FewShotPromptTemplate(
    examples=samples,
    example_prompt=prompt_sample,
    suffix="鲜花类型：{flower_type}\n适用场合：{occasion}",
    input_variables=["flower_type", "occasion"]
)
print(prompt.format(flower_type="野玫瑰", occasion="爱情"))


from langchain.chat_models import ChatOpenAI
llm = ChatOpenAI(
    model='gpt-3.5-turbo',
    temperature=0.5,
    max_tokens=200
)
res = llm.invoke(prompt.format(flower_type="野玫瑰", occasion="爱情"))
print(res)

from langchain.prompts.example_selector import SemanticSimilarityExampleSelector
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings

example_selector = SemanticSimilarityExampleSelector.from_examples(
    samples,
    OpenAIEmbeddings(),
    Chroma,
    k=1
)
prompt = FewShotPromptTemplate(
    example_selector=example_selector,
    example_prompt=prompt_sample,
    suffix="鲜花类型：{flower_type}\n适用场合：{occasion}",
    input_variables=["flower_type", "occasion"]
)
print(prompt.format(flower_type="野玫瑰", occasion="爱情"))

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model_name="gpt-4",
    temperature=0,
    api_key='your key',
    base_url="https://api.openai-hk.com/v1"
)

response = llm.invoke('如果 11+11=4，12+12=6，那么 13+13 是多少？')
print(response.content)

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model_name="gpt-4",
    temperature=0,
    api_key='your key',
    base_url="https://api.openai-hk.com/v1"
)

response = llm.invoke('如果 11+11=4，12+12=6，那么 13+13 是多少？一步步思考')
print(response.content)

from openai import OpenAI

client = OpenAI(
  api_key="your key",
  base_url="https://api.openai-hk.com/v1"
)

tool = """
1 tool: python_interpreter, description: use it to execute python code
2 tool: web_access, description: use it to get realtime info, input is the question or query 
"""

react_prompt = f"""
Try your best to answer user's question, and use the following format:

Question: the input question you must answer

Thought: you should always think about what to do

Action: the action to take, should use one of tools in the given tool list:

[{tool}]

Action Input: the input to the action

Here, you should pause the process and return to wait the outside observation. 

Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)

Thought: I now know the final answer

Final Answer: the final answer to the original input question
"""

def react_demo(request):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        temperature = 0,
        messages=[
            {"role": "system", "content": react_prompt},
            {"role": "user", "content": request}
        ]
      )
    print(response.choices[0].message.content)

react_demo("What is the capital of France?")

react_demo("广州今天适合穿什么?")

from langchain_community.document_loaders import PyPDFLoader

# 加载 pdf 文档
loader = PyPDFLoader("Spotmax_intro_cn_2020.pdf")
docs = loader.load()

# 文档分片
from langchain.text_splitter import RecursiveCharacterTextSplitter
text_spliter = RecursiveCharacterTextSplitter(chunk_size=200, chunk_overlap=10)

splits = text_spliter.split_documents(docs)
persist_directory = 'data/'

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
embedding = OpenAIEmbeddings()
# 创建向量数据库
vectordb = Chroma.from_documents(
    documents=splits,
    embedding=embedding,
    collection_name="spotmax",
    persist_directory=persist_directory,
)
# 持久化向量数据库
vectordb.persist()

def qa(question):
    from langchain_community.vectorstores import Chroma
    from langchain_openai import OpenAIEmbeddings
    embedding = OpenAIEmbeddings()
    vectordb = Chroma(persist_directory='data/', embedding_function=embedding, collection_name='spotmax')

    from langchain.chains.retrieval_qa.base import RetrievalQA
    from langchain_openai import ChatOpenAI

    llm = ChatOpenAI(
        model_name="gpt-3.5-turbo",
        temperature=0,
        max_tokens=200,
    )
    retriever = vectordb.as_retriever(
        search_type="mmr",
        search_kwargs={"k": 3}
    )
    qa0 = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever,
                                     return_source_documents=False, verbose=True)
    result = qa0({"query": question})
    return result['result']

print(qa("Spotmax 是什么？"))

def create_image(prompt):
    from openai import OpenAI
    client = OpenAI()
    response = client.images.generate(
        model='dall-e-2',
        prompt=prompt,
        size='256x256',
        quality='standard',
        n=1
    )
    u = response.data[0].url
    markdown_url = f"![image]({u})"
    return markdown_url

def query_web(question):
    """查询谷歌搜索结果"""
    from langchain_community.utilities import GoogleSerperAPIWrapper
    search = GoogleSerperAPIWrapper()
    return search.run(question)

from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
    model_name="gpt-4",
    temperature=0.7,
    max_tokens=1000,
)
from langchain.agents import Tool

tools = [
    Tool(
        name="Get current info",
        func=query_web,
        description="""only invoke it when you need to answer question about realtime info.
            And the input should be a search query."""
    ),
    Tool(
        name="query spotmax info",
        func=qa,
        description="""only invoke it when you need to get the info about spotmax/maxgroup/maxarch/maxchaos.
            And the input should be the question."""
    ),
    Tool(
        name="create an image",
        func=create_image,
        description="""invoke it when you need to create an image.
            And the input should be the description of the image."""
    )
]
from langchain.memory import ConversationBufferWindowMemory
from langchain.agents import ZeroShotAgent, AgentExecutor
from langchain.chains.llm import LLMChain

prefix = """Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:"""
suffix = """Begin!"

{chat_history}
Question: {input}
{agent_scratchpad}"""

prompt = ZeroShotAgent.create_prompt(
    tools,
    prefix=prefix,
    suffix=suffix,
    input_variables=["input", "chat_history", "agent_scratchpad"],
)
memory = ConversationBufferWindowMemory(k=10, memory_key="chat_history")

llm_chain = LLMChain(llm=llm, prompt=prompt)
agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools)
agent_chain = AgentExecutor.from_agent_and_tools(
    agent=agent, tools=tools, verbose=True, memory=memory, handle_parsing_errors=True

agent_chain.invoke(question)

import gradio as gr

with gr.Blocks() as demo:
    chatbot = gr.Chatbot(height=500) # 对话框
    msg = gr.Textbox(label="Prompt") # 输入框
    btn = gr.Button("Submit") # 按钮
    clear = gr.ClearButton(components=[msg, chatbot], value="Clear console") # 清除按钮

    btn.click(respond, inputs=[msg, chatbot], outputs=[msg, chatbot])
    msg.submit(respond, inputs=[msg, chatbot], outputs=[msg, chatbot])

gr.close_all()
demo.launch()

import gradio as gr

def qa(question):
    from langchain_community.vectorstores import Chroma
    from langchain_openai import OpenAIEmbeddings
    embedding = OpenAIEmbeddings()
    vectordb = Chroma(persist_directory='data1/', embedding_function=embedding, collection_name='spotmax')

    from langchain.chains.retrieval_qa.base import RetrievalQA
    from langchain_openai import ChatOpenAI

    llm = ChatOpenAI(
        model_name="gpt-3.5-turbo",
        temperature=0,
        max_tokens=200,
    )
    retriever = vectordb.as_retriever(
        search_type="mmr",
        search_kwargs={"k": 3}
    )
    qa0 = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever,
                                     return_source_documents=False, verbose=True)
    result = qa0({"query": question})
    return result['result']

def create_image(prompt):
    from openai import OpenAI
    client = OpenAI()
    response = client.images.generate(
        model='dall-e-2',
        prompt=prompt,
        size='256x256',
        quality='standard',
        n=1
    )
    u = response.data[0].url
    markdown_url = f"![image]({u})"
    return markdown_url

def query_web(question):
    """查询谷歌搜索结果"""
    from langchain_community.utilities import GoogleSerperAPIWrapper
    search = GoogleSerperAPIWrapper()
    return search.run(question)

def respond(message, chat_history):
    """对话函数"""
    bot_message = get_response(message)
    chat_history.append((message, bot_message))
    return "", chat_history

from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
    model_name="gpt-4",
    temperature=0.7,
    max_tokens=1000,
)
from langchain.agents import Tool

tools = [
    Tool(
        name="Get current info",
        func=query_web,
        description="""only invoke it when you need to answer question about realtime info.
            And the input should be a search query."""
    ),
    Tool(
        name="query spotmax info",
        func=qa,
        description="""only invoke it when you need to get the info about spotmax/maxgroup/maxarch/maxchaos.
            And the input should be the question."""
    ),
    Tool(
        name="create an image",
        func=create_image,
        description="""invoke it when you need to create an image.
            And the input should be the description of the image."""
    )
]
from langchain.memory import ConversationBufferWindowMemory
from langchain.agents import ZeroShotAgent, AgentExecutor
from langchain.chains.llm import LLMChain

prefix = """Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:"""
suffix = """Begin!"

{chat_history}
Question: {input}
{agent_scratchpad}"""

prompt = ZeroShotAgent.create_prompt(
    tools,
    prefix=prefix,
    suffix=suffix,
    input_variables=["input", "chat_history", "agent_scratchpad"],
)
memory = ConversationBufferWindowMemory(k=10, memory_key="chat_history")

llm_chain = LLMChain(llm=llm, prompt=prompt)
agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True, handle_parsing_errors=True)
agent_chain = AgentExecutor.from_agent_and_tools(
    agent=agent, tools=tools, verbose=True, memory=memory, handle_parsing_errors=True
)

def get_response(message):
    res = agent_chain.invoke(message)
    return res['output']

with gr.Blocks() as demo:
    chatbot = gr.Chatbot(height=500) # 对话框
    msg = gr.Textbox(label="Prompt") # 输入框
    btn = gr.Button("Submit") # 按钮
    clear = gr.ClearButton(components=[msg, chatbot], value="Clear console") # 清除按钮

    btn.click(respond, inputs=[msg, chatbot], outputs=[msg, chatbot])
    msg.submit(respond, inputs=[msg, chatbot], outputs=[msg, chatbot])

gr.close_all()
demo.launch()