eleven26

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()

from langchain_core.messages import SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI

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

def recognize_intent(text: str):
    response = llm.invoke([
        SystemMessage("""Recognize the intent from the user's input and format output as JSON string.
        The output JSON string includes: "intention", "parameters" """),
        HumanMessage(text)
    ])
    return response.content

print(recognize_intent("订8月19日北京到上海的飞机"))

from langchain_core.messages import SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI

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

def classify_sentiment(text: str):
    response = llm.invoke([
        SystemMessage("""根据给定文字所表述的情感，将文字分为三类：正面，中立，负面。请将用户给定的文字进行分类，并输出分类。"""),
        HumanMessage(text)
    ])
    return response.content

print(classify_sentiment("通过前面的课程我对大模型的认识提高了很多。"))
print(classify_sentiment("今天是2024年7月17日"))
print(classify_sentiment("最近感觉很累"))

from langchain_openai import ChatOpenAI

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

def book_flight(text: str):
    messages = [
        {"role": "system", "content": """
                通过用户描述，提取航班信息并以 JSON 格式输出。
                以下是一些示例：
                示例1
                输入：“订8月9日上海到北京的航班，上午出发
                输出："{"date":"0809","dispatch_time":"6-12","from":"上海","to":"北京"}"

                示例2
                输入：“订8月9日上海到北京的航班，下午出发
                输出："{"date":"0809","dispatch_time":"12-18","from":"上海","to":"北京"}"

                示例3
                输入：“订8月9日上海到北京的航班，晚上出发
                输出："{"date":"0809","dispatch_time":"21-18","from":"上海","to":"北京"}"

                示例4
                输入：“订8月9日上海到北京的航班
                输出："{"date":"0809","dispatch_time":"unknown","from":"上海","to":"北京"}"
                ”"""},
        {"role": "user", "content": text}
    ]
    response = llm.invoke(messages)
    return response.content

print(book_flight("预定9月1日广州到北京的航班，下午出发。"))
print(book_flight("预定9月1日广州到北京的航班"))
print(book_flight("预定9月1日夜里广州到北京的航班"))
print(book_flight("预定广州到北京的航班"))

from langchain.agents import initialize_agent, AgentType
from langchain_community.utilities import GoogleSerperAPIWrapper
from langchain_core.tools import Tool
from langchain_openai import ChatOpenAI

import os
# https://serper.dev
os.environ['SERPER_API_KEY'] = 'your serper api key'

llm = ChatOpenAI(
    model_name="yi-large",
    temperature=0.3,
    api_key='your key',
    base_url="https://api.lingyiwanwu.com/v1",
)

def query_web(question: str):
    search = GoogleSerperAPIWrapper()
    return search.run(question)

tools = [
    Tool(
        name="query_web",
        description="""当你需要回答关于当前信息的问题时调用。返回的是搜索引擎的搜索结果。参数为问题""",
        func=query_web
    )
]
agent = initialize_agent(tools, llm, agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

print(agent.run('今天广州适合穿什么？给我返回中文的输出'))

from langchain.agents import initialize_agent, AgentType
from langchain_community.utilities import GoogleSerperAPIWrapper
from langchain_core.tools import Tool
from langchain_openai import ChatOpenAI

import os
# https://serper.dev
os.environ['SERPER_API_KEY'] = 'your serper api key'

llm = ChatOpenAI(
    model_name="yi-large",
    temperature=0.3,
    api_key='your key',
    base_url="https://api.lingyiwanwu.com/v1",
)

def query_web(question: str):
    search = GoogleSerperAPIWrapper()
    return search.run(question)

def translate(text: str):
    yi_large_llm = ChatOpenAI(
        model_name="yi-large",
        temperature=0.3,
        api_key='your key',
        base_url="https://api.lingyiwanwu.com/v1",
    )

    return yi_large_llm.invoke(f'please translate "{text}" to Chinese')

tools = [
    Tool(
        name="query_web",
        description="""当你需要回答关于当前信息的问题时调用。返回的是搜索引擎的搜索结果。参数为问题""",
        func=query_web
    ),
    Tool(
        name="translate",
        description="""当你需要将英文翻译成中文时调用。返回的是翻译结果。参数为英文文本""",
        func=translate
    )
]
agent = initialize_agent(tools, llm, agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

print(agent.run('translate "hello" to Chinese'))

from langchain_openai import ChatOpenAI

chat = ChatOpenAI(
    model="yi-large",
    temperature=0.3,
    max_tokens=200,
    api_key='your key',
    base_url="https://api.lingyiwanwu.com/v1",
)

response = chat.invoke('今天广州天气晴朗，26~35摄氏度。')
print(response.content)

response = chat.invoke('今天广州适合穿什么？')
print(response.content)

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage

chat = ChatOpenAI(
    model="yi-large",
    temperature=0.3,
    max_tokens=200,
    api_key='your key',
    base_url="https://api.lingyiwanwu.com/v1",
)

messages = [
    HumanMessage('今天广州天气晴朗，26~35摄氏度。'),
]

response = chat.invoke(messages)

messages.append(AIMessage(response.content))
messages.append(HumanMessage('今天广州适合穿什么？'))

print(messages)

response = chat.invoke(messages)
print(response.content)

from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.messages import AIMessage
from langchain_core.runnables import RunnableWithMessageHistory
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferWindowMemory

llm = ChatOpenAI(
    model="yi-large",
    temperature=0.3,
    max_tokens=200,
    api_key='your key',
    base_url="https://api.lingyiwanwu.com/v1",
)

store = {}  # memory is maintained outside the chain
def get_session_history(session_id: str) -> InMemoryChatMessageHistory:
    if session_id not in store:
        store[session_id] = InMemoryChatMessageHistory()
        return store[session_id]

    memory = ConversationBufferWindowMemory(
        chat_memory=store[session_id],
        k=10,
        return_messages=True,
    )
    assert len(memory.memory_variables) == 1
    key = memory.memory_variables[0]
    messages = memory.load_memory_variables({})[key]
    store[session_id] = InMemoryChatMessageHistory(messages=messages)
    return store[session_id]

chain = RunnableWithMessageHistory(llm, get_session_history)

conf = {"configurable": {"session_id": "1"}}
response = chain.invoke('今天广州天气晴朗，26~35摄氏度。', config=conf) # type: AIMessage
print(f"response 1: {response.content}")

response = chain.invoke('今天广州适合穿什么？', config=conf) # type: AIMessage
print(f"response 2: {response.content}")

from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.messages import AIMessage
from langchain_core.runnables import RunnableWithMessageHistory
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferWindowMemory

llm = ChatOpenAI(
    model="yi-large",
    temperature=0.3,
    max_tokens=200,
    api_key='your key',
    base_url="https://api.lingyiwanwu.com/v1",
)

store = {}  # memory is maintained outside the chain
def get_session_history(session_id: str) -> InMemoryChatMessageHistory:
    if session_id not in store:
        store[session_id] = InMemoryChatMessageHistory()
        return store[session_id]

    memory = ConversationBufferWindowMemory(
        chat_memory=store[session_id],
        k=1,
        return_messages=True,
    )
    assert len(memory.memory_variables) == 1
    key = memory.memory_variables[0]
    # 返回最新的 k * 2 条消息
    messages = memory.load_memory_variables({})[key]
    store[session_id] = InMemoryChatMessageHistory(messages=messages)
    return store[session_id]

chain = RunnableWithMessageHistory(llm, get_session_history)

conf = {"configurable": {"session_id": "1"}}
response = chain.invoke('今天广州天气晴朗，26~35摄氏度。', config=conf) # type: AIMessage
print(f"response 1: {response.content}")

response = chain.invoke('这是一条无用的消息，请你忽略。', config=conf) # type: AIMessage
print(f"response 2: {response.content}")

response = chain.invoke('今天广州适合穿什么？', config=conf) # type: AIMessage
print(f"response 3: {response.content}")

def prune(self) -> None:
    """Prune buffer if it exceeds max token limit"""
    buffer = self.chat_memory.messages
    curr_buffer_length = self.llm.get_num_tokens_from_messages(buffer)
    if curr_buffer_length > self.max_token_limit:
        pruned_memory = []
        while curr_buffer_length > self.max_token_limit:
            pruned_memory.append(buffer.pop(0))
            curr_buffer_length = self.llm.get_num_tokens_from_messages(buffer)
        self.moving_summary_buffer = self.predict_new_summary(
            pruned_memory, self.moving_summary_buffer
        )