from langchain_openai.chat_models import ChatOpenAI from langchain_community.tools.tavily_search import TavilySearchResults from langchain.tools.render import format_tool_to_openai_function from langgraph.prebuilt import ToolExecutor,ToolInvocation from typing import TypedDict, Annotated, Sequence import operator from langchain_core.messages import BaseMessage,FunctionMessage,HumanMessage,AIMessage from langchain_community.tools import ShellTool,tool import json import os import gradio as gr os.environ["LANGCHAIN_TRACING_V2"] ="True" os.environ["LANGCHAIN_API_KEY"]="ls__54e16f70b2b0455aad0f2cbf47777d30" os.environ["OPENAI_API_KEY"]="20a79668d6113e99b35fcd541c65bfeaec497b8262c111bd328ef5f1ad8c6335" # os.environ["OPENAI_API_KEY"]="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" os.environ["LANGCHAIN_ENDPOINT"]="https://api.smith.langchain.com" os.environ["LANGCHAIN_PROJECT"]="default" os.environ['TAVILY_API_KEY'] = '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' class AgentState(TypedDict): messages: Annotated[Sequence[BaseMessage], operator.add] import time import jwt def generate_token(apikey: str, exp_seconds: int): try: id, secret = apikey.split(".") except Exception as e: raise Exception("invalid apikey", e) payload = { "api_key": id, "exp": int(round(time.time() * 1000)) + exp_seconds * 1000, "timestamp": int(round(time.time() * 1000)), } return jwt.encode( payload, secret, algorithm="HS256", headers={"alg": "HS256", "sign_type": "SIGN"}, ) from langchain_openai import ChatOpenAI # from jwt import generate_token def get_glm(temprature): llm = ChatOpenAI( model_name="glm-4", openai_api_base="https://open.bigmodel.cn/api/paas/v4", openai_api_key=generate_token("bdc66124ffee87e2cae1aff403831c29.IfV2i1fN822Bwj7X",10000), streaming=False, temperature=temprature ) return llm from langchain_core.prompts import ChatPromptTemplate prompt = ChatPromptTemplate.from_messages([ ("system", '''你是西游餐厅经理，你叫唐僧，能为顾客提供中餐服务; 你有三个员工，分别是：厨师八戒，侍者沙僧，收银悟空; 你需要根据顾客的需求,按照流程向员工下达指令,流程如下： 1.当顾客表达要点菜的意愿后，先判断是否属于中餐,如果不是,委婉的拒绝服务,如果是,执行下一步骤; 2.向厨师八戒下达指令，让八戒做菜,请顾客稍等; 3.判断菜是否做完,如果还没做完,继续等待;如果做完了，执行下一步骤; 4.向沙僧下达指令,让沙僧把菜端给顾客;请顾客品尝; 5.当顾客表达吃完了或者想结账的时候，向悟空下达指令,让悟空结账; 6.当结账完成后,向顾客表达感谢,并结束服务。 '''), ("assistant", "好的，我将严格遵守流程,并提供服务。") ]) @tool(return_direct=True) def chushi(query: str)->str: '''你是餐厅厨师八戒，能根据经理的指令，做出一道菜''' input={"input":query}, return "厨师八戒:接到指令,开始做菜!\n...\n菜已做好!" @tool def shizhe(query: str)->str: '''你是餐厅侍者沙僧，能根据经理的指令，把菜端到顾客面前''' input={"input":query} return "侍者沙僧:收到指令,开始送菜!\n...\n,菜已送到" @tool def shouyin(query: str)->str: '''你是餐厅收银悟空，能根据经理的指令，为顾客结账''' input={"input":query} return "结账完成，欢迎下次光临" tools=[chushi,shizhe,shouyin] from langchain_community.tools.convert_to_openai import format_tool_to_openai_tool model = get_glm(0.01).bind(tools=[format_tool_to_openai_tool(tool) for tool in tools]) tool_executor = ToolExecutor(tools) def should_continue(state): messages = state['messages'] last_message = messages[-1] # If there is no function call, then we finish if "tool_calls" not in last_message.additional_kwargs: return "end" # Otherwise if there is, we continue else: return "continue" # Define the function that calls the model def call_model(state): # global history messages = state['messages'] response = model.invoke(messages) # history.append([messages, response]) # We return a list, because this will get added to the existing list return {"messages": [response]} # Define the function to execute tools def call_tool(state): messages = state['messages'] # Based on the continue condition # we know the last message involves a function call last_message = messages[-1] # We construct an ToolInvocation from the function_call action = ToolInvocation( tool=last_message.additional_kwargs["tool_calls"][0]["function"]["name"], tool_input=json.loads(last_message.additional_kwargs["tool_calls"][0]["function"]["arguments"]), ) # We call the tool_executor and get back a response response = tool_executor.invoke(action) print(response) # We use the response to create a FunctionMessage function_message = HumanMessage(content=response) # function_message = FunctionMessage(content=str(response), name=action.tool) # We return a list, because this will get added to the existing list return {"messages": [function_message]} from langgraph.graph import StateGraph, END # Define a new graph workflow = StateGraph(AgentState) # Define the two nodes we will cycle between workflow.add_node("agent", call_model) workflow.add_node("action", call_tool) # Set the entrypoint as `agent` # This means that this node is the first one called workflow.set_entry_point("agent") # We now add a conditional edge workflow.add_conditional_edges( # First, we define the start node. We use `agent`. # This means these are the edges taken after the `agent` node is called. "agent", # Next, we pass in the function that will determine which node is called next. should_continue, # Finally we pass in a mapping. # The keys are strings, and the values are other nodes. # END is a special node marking that the graph should finish. # What will happen is we will call `should_continue`, and then the output of that # will be matched against the keys in this mapping. # Based on which one it matches, that node will then be called. { # If `tools`, then we call the tool node. "continue": "action", # Otherwise we finish. "end": END } ) # We now add a normal edge from `tools` to `agent`. # This means that after `tools` is called, `agent` node is called next. workflow.add_edge('action', 'agent') # Finally, we compile it! # This compiles it into a LangChain Runnable, # meaning you can use it as you would any other runnable app = workflow.compile() async def predict(message,history): history_langchain_format = [prompt.format()] for human, ai in history: history_langchain_format.append(HumanMessage(content=(human+"\n"),)) history_langchain_format.append(AIMessage(content=(ai+"\n"),)) history_langchain_format.append(HumanMessage(content=(message+'\n'))) que={"messages": history_langchain_format} # que={"messages": [HumanMessage(content=message)]} # que={"messages":[prompt.format(input=message)]} res=app.invoke(que) if res: mess_list=res["messages"][2:] print(mess_list) res_str="" for i in mess_list: response=i.content print(response) res_str+=(response+'\n') return(res_str) # for j in range(len(response)): # time.sleep(0.3) # yield response[: j+1] else:print("不好意思，出了一个小问题，请联系我的微信：13603634456") demo = gr.ChatInterface(fn=predict, title="西游餐厅",description="西游餐厅开张了，我是经理唐僧，欢迎光临,您有什么需求,可以直接问我哦！",) demo.launch()