UnisKB/apps/system_manage/mcp_agent.py

114 lines
6.7 KiB
Python

"""Streaming-compatible LangChain tools backed by the shared component runtime."""
import asyncio
import hashlib
import json
import re
from django.db import close_old_connections
from rest_framework.exceptions import ValidationError
from system_manage import mcp_registry as registry, mcp_runtime as runtime
def context_for(body, *, engine_tools=None, tool_ids=None, custom=None, transform=None, node_id=None):
from application.models import Application, ApplicationKnowledgeMapping
from users.models import User
app = Application.objects.get(pk=body['application_id'], workspace_id=body['workspace_id'])
user = User.objects.get(pk=body.get('engine_user_id') or app.user_id, is_active=True)
knowledge_ids = body.get('knowledge_id_list')
if knowledge_ids is None:
knowledge_ids = list(ApplicationKnowledgeMapping.objects.filter(application=app).values_list('knowledge_id', flat=True))
return {'workspace': app.workspace_id, 'user': user, 'application_id': str(app.id), 'chat_id': body.get('chat_id'),
'parent': body.get('engine_task_id'), 'tool_ids': tool_ids or [], 'custom': custom,
'transform': transform, 'engine_tools': engine_tools or [],
'scope': {**{key: body.get(key) for key in ('chat_user_id', 'chat_user_type', 'knowledge_version_map', 'chat_record_id')},
'knowledge_setting': body.get('knowledge_setting') or {},
'viewer_id': str(body['chat_user_id']) if body.get('chat_user_type') in ('PLATFORM_USER', 'SYSTEM_USER') and body.get('chat_user_id') else None,
'knowledge_ids': [str(key) for key in knowledge_ids], 'fixed_knowledge_scope': True,
'node_id': node_id, 'source': 'workflow-chat' if node_id else 'knowledge-chat'}}
async def db_call(function, *args, **kwargs):
def run():
close_old_connections()
try:
return function(*args, **kwargs)
finally:
close_old_connections()
return await asyncio.to_thread(run)
def call_records(body, node_id=None):
from system_manage.models.ai_hub import AITask
if not body.get('chat_id'):
return []
query = AITask.objects.filter(workspace_id=body['workspace_id'], snapshot__trace__chat_id=str(body['chat_id']))
if body.get('chat_record_id'):
query = query.filter(snapshot__trace__chat_record_id=str(body['chat_record_id']))
if node_id:
query = query.filter(snapshot__trace__node_id=str(node_id))
return [{'id': str(task.id), 'status': task.status, 'component_id': task.snapshot.get('resources', [''])[0],
'artifact_id': task.result.get('artifact_id')} for task in query.order_by('created_at')[:50]]
async def tools(context):
from langchain_core.tools import StructuredTool
result = []
workspace, user = context['workspace'], context['user']
entries = []
for pk in dict.fromkeys(context['tool_ids']):
key = 'mcp:' + str(pk)
_, obj = await db_call(registry.resolve, workspace, user, key)
servers = runtime.connections(obj.code)
if context.get('transform'):
servers = context['transform'](servers)
entries.append((key, servers))
if context.get('custom'):
await db_call(registry.resolve, workspace, user, 'mcp-custom')
entries.append(('mcp-custom', runtime.connections(context['custom'])))
def bind_mcp(key, item, servers):
async def call(**arguments):
try:
output = await db_call(runtime.invoke, workspace, user, key,
{'servers': servers, 'server': item['server'], 'tool': item['name'], 'arguments': arguments},
parent=context.get('parent'), application_id=context['application_id'], chat_id=context.get('chat_id'),
scope=context.get('scope'), connection_overrides=servers, priority=8)
return json.dumps(output, ensure_ascii=False, default=str)
except ValidationError:
return json.dumps({'error': '工具不可用或执行失败,请检查工具状态后重试'}, ensure_ascii=False)
return call
discovered_entries = [(key, servers, await db_call(runtime.discover, servers)) for key, servers in entries]
from collections import Counter
def base_name(item):
return re.sub(r'[^a-zA-Z0-9_-]', '_', item['name'])[:40] or 'tool'
counts = Counter(base_name(item) for _, _, discovered in discovered_entries for item in discovered)
for key, servers, discovered in discovered_entries:
for item in discovered:
identity = key + ':' + item['server'] + ':' + item['name']
name = base_name(item)
alias = name if counts[name] == 1 and name == item['name'] and name not in ('search_knowledge', 'save_mindmap') else (
name + '_' + hashlib.sha256(identity.encode()).hexdigest()[:12])
result.append(StructuredTool.from_function(coroutine=bind_mcp(key, item, servers), name=alias,
description=f"{item['description']} ({item['server']} / {item['name']})", args_schema=item['args_schema']))
schemas = {
'knowledge-search': ('search_knowledge', '检索当前应用已关联且获授权的知识库,返回片段与文档引用。',
{'type': 'object', 'properties': {'text': {'type': 'string'}}, 'required': ['text']}),
'mindmap-save': ('save_mindmap', '将已整理的 Markdown 保存为可编辑思维导图,返回打开导图链接。仅在用户要求生成或保存导图时调用。',
{'type': 'object', 'properties': {'text': {'type': 'string'}, 'name': {'type': 'string'}}, 'required': ['text']}),
}
def bind_builtin(key):
async def call(**arguments):
value = await db_call(runtime.invoke, workspace, user, key, arguments,
parent=context.get('parent'), application_id=context['application_id'], chat_id=context.get('chat_id'),
scope=context.get('scope'), priority=8)
return json.dumps(value, ensure_ascii=False, default=str)
return call
for key in dict.fromkeys(context.get('engine_tools', [])):
if key not in schemas:
raise ValidationError('平台能力无效')
if key == 'mindmap-save' and context.get('scope', {}).get('chat_user_type') not in (None, 'PLATFORM_USER', 'SYSTEM_USER'):
# Saved workbench artifacts require a platform identity; public chat keeps its original behavior.
continue
await db_call(registry.resolve, workspace, user, key)
name, description, schema = schemas[key]
result.append(StructuredTool.from_function(coroutine=bind_builtin(key), name=name, description=description, args_schema=schema))
return result