lei_y601/yj_room_agent
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat:整改会议预订助手-接入langgrah,增加意图识别

Browse Source
This commit is contained in:
雷雨
2025-11-13 16:07:45 +08:00
parent 13fc8fec82
commit 02b56ac1ea
13 changed files with 372 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
.env
View File

@@ -1,11 +1,11 @@
#api key
MODEL_API_KEY=sk-7391d759f1e4488f82c2d278b977c359
MODEL_API_KEY=sk-jixyuwdltfawojgwywogkkdoqwpxblabprxybltlacbpqnip
#模型地址
MODEL_BASE_URL=http://10.254.23.128:31205/v1
MODEL_BASE_URL=https://api.siliconflow.cn/v1
#模型名称
MODEL_NAME=deepseek_70B
MODEL_NAME=Qwen/Qwen3-Next-80B-A3B-Instruct
#模型活跃度
MODEL_TEMPERATURE=0.1
MODEL_TEMPERATURE=0.4
#放行host地址
DJANGO_ALLOWED_HOSTS=192.168.237.130,127.0.0.1,10.212.26.130,192.168.31.115
#是否开启debug模式

33
prompt_template.yaml Normal file
View File

@@ -0,0 +1,33 @@
template:
#意图识别节点-系统提示词
intent_recognition: |
# 角色与目标
你是一个专业的意图识别模块，是会议室预订智能体的核心决策中枢。你的唯一职责是根据用户的当前提问和聊天历史，准确判断用户的核心意图，并将其映射到指定的下游处理节点。
# 上下文信息
你将作为 Langgraph 工作流中的一个节点存在。你的输出（一个 JSON 对象）将直接用于决定下一步应该调用哪个功能节点（如预订会议室、查询预订等）。你的判断必须精准、高效。
<节点名称> 必须是且仅是以下四个选项之一：
book_meeting - 当用户明确表示要预订/预约会议室时
cancel_meeting - 当用户明确表示要取消已预订的会议室时
query_meeting - 当用户查询已预订的会议室信息时
unknown - 当意图不明确或超出上述三种情况时
# 输入信息
当前时间:<current_time>{current_time}</current_time>
用户输入信息:<user_input>{user_input}</user_input>
history【历史对话消息】:<history>{history}</history>
# 输出信息
<意图摘要> 是对该意图的简短描述（不超过50字符）
你必须严格遵守以下 JSON 格式进行输出，不包含任何其他解释性文字或代码块标记：
{{"node": "<节点名称>", "summary": "<意图摘要>"}}
result_summary: |
你是一个会议预订智能体的自然语言生成模块，用户的请求已经由系统模块处理并调用了相应的API。请阅读API返回的结构化结果数据，并将其用自然语言进行解释和总结后呈现给用户。你的任务是根据API返回的内容，输出清晰、准确、友好的反馈信息。
用户操作可能包括查询空闲会议室、预订会议室、取消预订、查询已预订会议等
#你需要完成的任务：
准确解析API返回的数据结构。
识别结果是否成功（是否有“error”字段或status不为200等）。
如果结果成功，请用自然、简洁的方式向用户说明具体信息。
如果结果中出现错误，请以友好、易于理解的方式提示错误信息，并可提供适当建议。
处理结果信息时尽量“结构化解析”，避免遗漏关键信息（如时间、会议室名称、人数等）
使用口语化中文，避免生硬术语。
#用户数据:
{user_operation}
<data>{data}</data>

5
requirements.txt
View File

@@ -4,4 +4,7 @@ python-decouple==3.8
APScheduler==3.11.0
pydantic-ai==0.3.6
gunicorn==23.0.0
redis==6.2.0
redis==6.2.0
langgraph
langchain-openai
SQLAlchemy

0
yj_room_agent/db/__init__.py Normal file
View File

19
yj_room_agent/db/db_main.py Normal file
View File

@@ -0,0 +1,19 @@
from datetime import datetime
from django.db import models
from django.db.models import Q, CheckConstraint
'''
会话表
'''
class Conversation(models.Model):
id = models.CharField(max_length=100, primary_key=True)
create_time = models.DateTimeField(default=datetime.now())
content = models.TextField(null=False)
user_id = models.CharField(max_length=100, null=False)
cvs_id = models.CharField(max_length=100, null=False)
role = models.CharField(max_length=100, null=False)
meta = models.TextField(null=True)
class Meta:
db_table = 'db_conversation'

77
yj_room_agent/db/snow_id.py Normal file
View File

@@ -0,0 +1,77 @@
import time
import threading
class Snowflake:
def __init__(self, worker_id, datacenter_id):
# 初始化起始时间（2020-01-01）
self.epoch = 1577836800000
# 结构配置
self.worker_id_bits = 5
self.datacenter_id_bits = 5
self.sequence_bits = 12
# 最大值计算
self.max_worker_id = -1 ^ (-1 << self.worker_id_bits)
self.max_datacenter_id = -1 ^ (-1 << self.datacenter_id_bits)
# 移位偏移量
self.worker_id_shift = self.sequence_bits
self.datacenter_id_shift = self.sequence_bits + self.worker_id_bits
self.timestamp_shift = self.sequence_bits + self.worker_id_bits + self.datacenter_id_bits
# 序列号掩码
self.sequence_mask = -1 ^ (-1 << self.sequence_bits)
# 参数校验
if worker_id > self.max_worker_id or worker_id < 0:
raise ValueError(f"Worker ID需在0~{self.max_worker_id}之间")
if datacenter_id > self.max_datacenter_id or datacenter_id < 0:
raise ValueError(f"Datacenter ID需在0~{self.max_datacenter_id}之间")
self.worker_id = worker_id
self.datacenter_id = datacenter_id
self.sequence = 0
self.last_timestamp = -1
self.lock = threading.Lock()
def _current_time(self):
"""获取当前毫秒时间戳"""
return int(time.time() * 1000)
def _wait_next_millis(self, last_timestamp):
"""等待至下一毫秒"""
timestamp = self._current_time()
while timestamp <= last_timestamp:
time.sleep(0.001)
timestamp = self._current_time()
return timestamp
def generate_id(self):
with self.lock:
timestamp = self._current_time()
# 时钟回拨检测
if timestamp < self.last_timestamp:
raise ValueError(f"时钟回拨异常！时间差：{self.last_timestamp - timestamp}ms")
# 同一毫秒序列号递增
if timestamp == self.last_timestamp:
self.sequence = (self.sequence + 1) & self.sequence_mask
if self.sequence == 0:
timestamp = self._wait_next_millis(self.last_timestamp)
else:
self.sequence = 0
self.last_timestamp = timestamp
return ((timestamp - self.epoch) << self.timestamp_shift) | \
(self.datacenter_id << self.datacenter_id_shift) | \
(self.worker_id << self.worker_id_shift) | \
self.sequence
id_generator = Snowflake(worker_id=1, datacenter_id=1)
def next_id():
return id_generator.generate_id()

0
yj_room_agent/graph/__init__.py Normal file
View File

144
yj_room_agent/graph/room_meeting_graph_agent.py Normal file
View File

@@ -0,0 +1,144 @@
import orjson
from decouple import config
from datetime import datetime
from langchain_openai import ChatOpenAI
from typing import TypedDict, Annotated, List, Optional, Union
import logging
from yj_room_agent.db import snow_id, db_main
from yj_room_agent.template import template
from yj_room_agent.tools import json_tools
from langgraph.graph import StateGraph, END, START
from langgraph.checkpoint.memory import MemorySaver
room_llm = ChatOpenAI(
model=config('MODEL_NAME', default=''),
base_url=config('MODEL_BASE_URL', default=''),
temperature=config('MODEL_TEMPERATURE', default=0.5, cast=float),
max_tokens=8000,
max_retries=2,
api_key=config('MODEL_API_KEY', default='empty'),
)
logger = logging.getLogger('django')
class RoomChatAgentState(TypedDict):
user_query: str
conversation_id: str
user_id: str
params: dict
history: Optional[list]
# 用户意图
user_intention: Optional[dict]
user_intention_error: Optional[str]
# 上一个执行节点
last_node: Optional[str]
result_summary: Optional[str]
result_error: Optional[str]
# data_数据
query_meeting_data: Optional[dict | str]
book_meeting_data: Optional[dict | str]
cancel_meeting_data: Optional[dict | str]
'''
用户意图识别节点
'''
def intent_recognition_node(state: RoomChatAgentState) -> dict:
logger.info(
f"user:{state.get('user_id', '1')} ---------------进入 intent_recognition_node(意图识别) 节点---------------")
user_query = state.get('user_query', '')
history = state.get('history', [])
user_id = state.get('user_id', '')
xx_template = template.get_base_template()
sys_template = xx_template['template']['intent_recognition']
sys_template = sys_template.format(history=history, user_input=user_query,
current_time=datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
resp = room_llm.invoke(sys_template).text()
logger.info(f"user:{user_id} intent_recognition_node(意图识别) 节点返回结果:{resp}")
resp = json_tools.extract_nested_json(resp)
result = orjson.loads(resp)
if result is None or type(result) is not dict:
logger.error(f"user:{user_id} intent_recognition_node(意图识别) 节点返回结果:{resp} 解析失败")
return {'user_intention': None,
'user_intention_error': f"user:{user_id} intent_recognition_node(意图识别) 节点返回结果:{resp} 解析失败"}
return {'user_intention': result}
def intent_recognition_node_handler(state: RoomChatAgentState) -> str:
user_intention = state.get('user_intention', {})
if user_intention is None:
return END
node = user_intention.get('node', '')
if node == '' or node == 'unknown':
logger.error(f"user:{state.get('user_id', '1')} 未知意图:{user_intention}")
return END
return node
#预约会议，需要判断历史消息或者用户输入，判断是否有会议室号，如果有，则预约会议，如果没有，触发查询空闲会议室
def book_meeting_node(state: RoomChatAgentState) -> dict:
logger.info(f"user:{state.get('user_id', '1')} ---------------进入 book_meeting_node(预约会议) 节点-")
return {}
#取消会议室，需要判断历史消息或者用户输入，判断是否有会议室号，如果有，则取消会议，如果没有，触发查询已预订会议
def cancel_meeting_node(state: RoomChatAgentState) -> dict:
logger.info(f"user:{state.get('user_id', '1')} ---------------进入 cancel_meeting_node(取消会议) 节点-")
return {}
#查询已预订会议，需要判断历史消息或者用户输入，查询已预订会议，返回结果
def query_meeting_node(state: RoomChatAgentState) -> dict:
logger.info(f"user:{state.get('user_id', '1')} ---------------进入 query_meeting_node(查询已预订会议) 节点-")
# 示例数据,后面替换用友查询接口数据
example_data = {
'meeting_list': [
{'meeting_id': '12345',
'meeting_room': '成都527',
'meeting_time': '2025-11-17 10:00:00',
'meeting_duration': '30分钟',
'meeting_users': ['张三', '王华']
}
]
}
return {'query_meeting_data': example_data, 'last_node': 'query_meeting'}
#结果汇总节点，根据上一个节点的返回结果，生成结果汇总模板，返回结果，结束会话
def _result_summary_node(state: RoomChatAgentState) -> dict:
logger.info(f"user:{state.get('user_id', '1')} ---------------进入 _result_summary_node(结果汇总) 节点-")
last_node = state.get('last_node', '')
node_msg = ''
data = None
if last_node == 'book_meeting':
node_msg = '用户调用APi预订会议数据如下:'
data = state.get('book_meeting_data', None)
if last_node == 'cancel_meeting':
node_msg = '用户调用APi取消会议结果如下:'
data = state.get('cancel_meeting_data', None)
if last_node == 'query_meeting':
node_msg = '用户调用APi查询已预订会议结果如下:'
data = state.get('query_meeting_data', None)
template_msg = template.get_base_template()
result_summary = template_msg['template']['result_summary']
result_summary = result_summary.format(user_operation=node_msg, data=data)
logger.info(f"大模型汇总结果模板：{result_summary}")
resp = room_llm.invoke(result_summary).text()
return {'result_summary': resp}
workflow = StateGraph(RoomChatAgentState)
workflow.add_node("_intent_recognition", intent_recognition_node)
workflow.add_node("book_meeting", book_meeting_node)
workflow.add_node("cancel_meeting", cancel_meeting_node)
workflow.add_node("query_meeting", query_meeting_node)
workflow.add_node("_result_summary", _result_summary_node)
workflow.add_edge(START, "_intent_recognition")
workflow.add_conditional_edges('_intent_recognition', intent_recognition_node_handler,
[END, 'book_meeting', 'cancel_meeting', 'query_meeting'])
workflow.add_edge("_result_summary", END)
workflow.add_edge("book_meeting", END)
workflow.add_edge("cancel_meeting", END)
workflow.add_edge("query_meeting", '_result_summary')
memory = MemorySaver()
room_chat_agent = workflow.compile(checkpointer=memory)

0
yj_room_agent/template/__init__.py Normal file
View File

15
yj_room_agent/template/template.py Normal file
View File

@@ -0,0 +1,15 @@
import yaml
base_template = None
def load():
with open('./prompt_template.yaml', 'r', encoding='utf-8') as f:
global base_template
base_template = yaml.load(f, Loader=yaml.SafeLoader)
def get_base_template():
if not base_template:
load()
return base_template

31
yj_room_agent/tools/json_tools.py Normal file
View File

@@ -0,0 +1,31 @@
import orjson
import logging
logger = logging.getLogger('django')
def extract_nested_json(text):
stack = []
start_index = -1
results = []
if not text:
logger.warning("extract_nested_json: text is empty")
for i, char in enumerate(text):
if char in '{[':
if not stack: # 记录起始位置
start_index = i
stack.append(char)
elif char in '}]':
if stack and ((char == '}' and stack[-1] == '{') or (char == ']' and stack[-1] == '[')):
stack.pop()
if not stack: # 栈空时截取完整JSON
json_str = text[start_index:i + 1]
try:
orjson.loads(json_str) # 验证有效性
results.append(json_str)
except:
pass
else:
stack = [] # 括号不匹配则重置
if len(results) > 0 and results[0]:
return results[0]
return None

5
yj_room_agent/urls.py
View File

@@ -16,18 +16,19 @@ Including another URLconf
"""
from django.contrib import admin
from django.urls import path
from yj_room_agent import views
from yj_room_agent import views
urlpatterns = [
path('admin/', admin.site.urls),
path('test/', views.hello, name='hello'),
path('book_room/', views.room_chat, name='room_chat'),
path('book_room_2/', views.room_chat_2, name='room_chat_2'),
path('getMeetingType/', views.query_meeting_type),
path('getMeeting/', views.query_meeting),
path('getMeetingBookingDetails/', views.query_meetingooking_info),
path('bookMeeting/', views.book_meeting),
path('cancelMeeting/', views.cancel_meeting),
path('editMeeting/',views.edit_meeting),
path('editMeeting/', views.edit_meeting),
path('yj-agent-api/tianyi_chatbot', views.tian_yi_chat_bot, name='tianyi_chatbot'),
]

55
yj_room_agent/views.py
View File

@@ -5,10 +5,14 @@ from django.views.decorators.http import require_POST
import json
import requests
from .tools import getinfo
from .tianyi_ai import knowledge_chat
from .tianyi_ai import knowledge_chat
from yj_room_agent.graph.room_meeting_graph_agent import RoomChatAgentState, room_chat_agent
import uuid
def hello(request):
return JsonResponse({'msg': 'ok'})
def query_meeting_type(request):
"""
query_params:
@@ -31,11 +35,12 @@ def query_meeting_type(request):
result = getinfo.query_meetingroom_type(params)
content = json.loads(json.dumps(result))
print("room type :",content)
print("room type :", content)
return JsonResponse(content)
except Exception as ex:
return JsonResponse(str(ex))
def query_meeting(request):
"""
query_params:
@@ -60,7 +65,7 @@ def query_meeting(request):
result = getinfo.query_meetingroom(params)
content = json.loads(json.dumps(result))
print("content :",content)
print("content :", content)
return JsonResponse(content)
except Exception as ex:
return JsonResponse(str(ex))
@@ -93,16 +98,15 @@ def query_meetingooking_info(request):
params['access_token'] = access_token
print("params is -----", params)
result = getinfo.query_meetingbooking_info(params)
print("params is -----",params)
print("params is -----", params)
result = params_filter.filter_state(result)
content = json.loads(json.dumps(result))
print("content is ------------------ :",content)
print("content is ------------------ :", content)
return JsonResponse(content)
except Exception as ex:
return JsonResponse(str(ex))
def book_meeting(request):
"""
data{
@@ -130,7 +134,7 @@ def book_meeting(request):
params = request.GET.dict()
yht_token = ((request.META.get('HTTP_YHT_ACCESS_TOKEN', None))
or request.headers.get('yht_access_token', None))
or request.headers.get('yht_access_token', None))
print("yht is {0}".format(yht_token))
if yht_token:
params['yht_access_token'] = yht_token
@@ -152,6 +156,7 @@ def book_meeting(request):
except Exception as ex:
return JsonResponse(str(ex))
def edit_meeting(request):
"""
:params:
@@ -175,7 +180,7 @@ def edit_meeting(request):
params = request.GET.dict()
yht_token = ((request.META.get('HTTP_YHT_ACCESS_TOKEN', None))
or request.headers.get('yht_access_token', None))
or request.headers.get('yht_access_token', None))
print("yht is {0}".format(yht_token))
if yht_token:
params['yht_access_token'] = yht_token
@@ -189,7 +194,7 @@ def edit_meeting(request):
access_token = getinfo.get_access_token(tenant_id)
params['access_token'] = access_token
result = getinfo.edit_meeting_info(params,data)
result = getinfo.edit_meeting_info(params, data)
content = json.loads(json.dumps(result))
print("content :", content)
return JsonResponse(content)
@@ -227,7 +232,6 @@ def cancel_meeting(request):
return JsonResponse(str(ex))
@require_POST
def room_chat(request):
params = request.GET.dict()
@@ -244,13 +248,38 @@ def room_chat(request):
return JsonResponse(resp)
@require_POST
def room_chat_2(request):
params = request.GET.dict()
yht_token = ((request.META.get('HTTP_YHT_ACCESS_TOKEN', None))
or request.headers.get('yht_access_token', None))
if yht_token:
params['yht_access_token'] = yht_token
if not yht_token:
ckk = request.COOKIES
params['yht_access_token'] = ckk.get('yht_access_token', None)
body = json.loads(request.body)
history = []
config = {"configurable": {"thread_id": str(uuid.uuid4())}}
state: RoomChatAgentState = {
'params': params,
'user_query': body['user_query'],
'user_id': body['user_id'],
'history': history,
'conversation_id': body['covers_id'],
}
resp = room_chat_agent.invoke(state,config=config)
return JsonResponse(resp)
@require_POST
def tian_yi_chat_bot(request):
data = json.loads(request.body)
user_query = data.get('user_query')
session_id = data.get('session_id')
if not user_query:
return JsonResponse(data={'message':'user_query 不能为空'},status=400)
return JsonResponse(data={'message': 'user_query 不能为空'}, status=400)
if not session_id:
return JsonResponse(data={'message': 'session_id 不能为空'},status=400)
return StreamingHttpResponse(knowledge_chat.do_chat_with_bot(user_query,session_id),content_type='text/html; charset=utf-8')
return JsonResponse(data={'message': 'session_id 不能为空'}, status=400)
return StreamingHttpResponse(knowledge_chat.do_chat_with_bot(user_query, session_id),
content_type='text/html; charset=utf-8')