AI_POC/TERES_fastapi_backend
12
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v0.21.1-fastapi

Browse Source
This commit is contained in:
dangzerong
2025-11-04 16:06:36 +08:00
parent 3e58c3d0e9
commit d57b5d76ae
218 changed files with 19617 additions and 72339 deletions
Download Patch File Download Diff File Expand all files Collapse all files

290
api/apps/mcp_server_app.py
View File

@@ -13,164 +13,61 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
from typing import List, Optional, Dict, Any
from fastapi import APIRouter, Depends, HTTPException, Query
from fastapi.security import HTTPAuthorizationCredentials
from api.utils.api_utils import security
from fastapi import APIRouter, Depends, Query
from api.apps.models.auth_dependencies import get_current_user
from api.apps.models.mcp_models import (
ListMCPServersQuery,
ListMCPServersBody,
CreateMCPServerRequest,
UpdateMCPServerRequest,
DeleteMCPServersRequest,
ImportMCPServersRequest,
ExportMCPServersRequest,
ListMCPToolsRequest,
TestMCPToolRequest,
CacheMCPToolsRequest,
TestMCPRequest,
)
from api import settings
from api.db import VALID_MCP_SERVER_TYPES
from api.db.db_models import MCPServer, User
from api.db.db_models import MCPServer
from api.db.services.mcp_server_service import MCPServerService
from api.db.services.user_service import TenantService
from api.settings import RetCode
from api.utils import get_uuid
from api.utils.api_utils import get_data_error_result, get_json_result, server_error_response, get_mcp_tools
from api.utils.web_utils import get_float, safe_json_parse
from api.utils.web_utils import safe_json_parse
from rag.utils.mcp_tool_call_conn import MCPToolCallSession, close_multiple_mcp_toolcall_sessions
from pydantic import BaseModel
# Security
# Pydantic models for request/response
class ListMCPRequest(BaseModel):
mcp_ids: List[str] = []
class CreateMCPRequest(BaseModel):
name: str
url: str
server_type: str
headers: Optional[Dict[str, Any]] = {}
variables: Optional[Dict[str, Any]] = {}
timeout: Optional[float] = 10
class UpdateMCPRequest(BaseModel):
mcp_id: str
name: Optional[str] = None
url: Optional[str] = None
server_type: Optional[str] = None
headers: Optional[Dict[str, Any]] = None
variables: Optional[Dict[str, Any]] = None
timeout: Optional[float] = 10
class RemoveMCPRequest(BaseModel):
mcp_ids: List[str]
class ImportMCPRequest(BaseModel):
mcpServers: Dict[str, Dict[str, Any]]
timeout: Optional[float] = 10
class ExportMCPRequest(BaseModel):
mcp_ids: List[str]
class ListToolsRequest(BaseModel):
mcp_ids: List[str]
timeout: Optional[float] = 10
class TestToolRequest(BaseModel):
mcp_id: str
tool_name: str
arguments: Dict[str, Any]
timeout: Optional[float] = 10
class CacheToolsRequest(BaseModel):
mcp_id: str
tools: List[Dict[str, Any]]
class TestMCPRequest(BaseModel):
url: str
server_type: str
timeout: Optional[float] = 10
headers: Optional[Dict[str, Any]] = {}
variables: Optional[Dict[str, Any]] = {}
# Dependency injection
async def get_current_user(credentials: HTTPAuthorizationCredentials = Depends(security)):
"""获取当前用户"""
from api.db import StatusEnum
from api.db.services.user_service import UserService
from fastapi import HTTPException, status
import logging
try:
from itsdangerous.url_safe import URLSafeTimedSerializer as Serializer
except ImportError:
# 如果没有itsdangerous，使用jwt作为替代
import jwt
Serializer = jwt
jwt = Serializer(secret_key=settings.SECRET_KEY)
authorization = credentials.credentials
if authorization:
try:
access_token = str(jwt.loads(authorization))
if not access_token or not access_token.strip():
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Authentication attempt with empty access token"
)
# Access tokens should be UUIDs (32 hex characters)
if len(access_token.strip()) < 32:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail=f"Authentication attempt with invalid token format: {len(access_token)} chars"
)
user = UserService.query(
access_token=access_token, status=StatusEnum.VALID.value
)
if user:
if not user[0].access_token or not user[0].access_token.strip():
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail=f"User {user[0].email} has empty access_token in database"
)
return user[0]
else:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid access token"
)
except Exception as e:
logging.warning(f"load_user got exception {e}")
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid access token"
)
else:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Authorization header required"
)
# Create router
# 创建路由器
router = APIRouter()
@router.post("/list")
async def list_mcp(
request: ListMCPRequest,
keywords: str = Query("", description="Search keywords"),
page: int = Query(0, description="Page number"),
page_size: int = Query(0, description="Items per page"),
orderby: str = Query("create_time", description="Order by field"),
desc: bool = Query(True, description="Sort descending"),
current_user: User = Depends(get_current_user)
query: ListMCPServersQuery = Depends(),
body: ListMCPServersBody = None,
current_user = Depends(get_current_user)
):
"""列出MCP服务器"""
if body is None:
body = ListMCPServersBody()
keywords = query.keywords or ""
page_number = int(query.page or 0)
items_per_page = int(query.page_size or 0)
orderby = query.orderby or "create_time"
desc = query.desc.lower() == "true" if query.desc else True
mcp_ids = body.mcp_ids or []
try:
servers = MCPServerService.get_servers(current_user.id, request.mcp_ids, 0, 0, orderby, desc, keywords) or []
servers = MCPServerService.get_servers(current_user.id, mcp_ids, 0, 0, orderby, desc, keywords) or []
total = len(servers)
if page and page_size:
servers = servers[(page - 1) * page_size : page * page_size]
if page_number and items_per_page:
servers = servers[(page_number - 1) * items_per_page : page_number * items_per_page]
return get_json_result(data={"mcp_servers": servers, "total": total})
except Exception as e:
@@ -179,9 +76,10 @@ async def list_mcp(
@router.get("/detail")
async def detail(
mcp_id: str = Query(..., description="MCP server ID"),
current_user: User = Depends(get_current_user)
mcp_id: str = Query(..., description="MCP服务器ID"),
current_user = Depends(get_current_user)
):
"""获取MCP服务器详情"""
try:
mcp_server = MCPServerService.get_or_none(id=mcp_id, tenant_id=current_user.id)
@@ -195,9 +93,10 @@ async def detail(
@router.post("/create")
async def create(
request: CreateMCPRequest,
current_user: User = Depends(get_current_user)
request: CreateMCPServerRequest,
current_user = Depends(get_current_user)
):
"""创建MCP服务器"""
server_type = request.server_type
if server_type not in VALID_MCP_SERVER_TYPES:
return get_data_error_result(message="Unsupported MCP server type.")
@@ -218,10 +117,10 @@ async def create(
variables = safe_json_parse(request.variables or {})
variables.pop("tools", None)
timeout = request.timeout or 10
timeout = request.timeout or 10.0
try:
req_data = {
req = {
"id": get_uuid(),
"tenant_id": current_user.id,
"name": server_name,
@@ -229,7 +128,6 @@ async def create(
"server_type": server_type,
"headers": headers,
"variables": variables,
"timeout": timeout
}
e, _ = TenantService.get_by_id(current_user.id)
@@ -244,46 +142,45 @@ async def create(
tools = server_tools[server_name]
tools = {tool["name"]: tool for tool in tools if isinstance(tool, dict) and "name" in tool}
variables["tools"] = tools
req_data["variables"] = variables
req["variables"] = variables
if not MCPServerService.insert(**req_data):
if not MCPServerService.insert(**req):
return get_data_error_result("Failed to create MCP server.")
return get_json_result(data=req_data)
return get_json_result(data=req)
except Exception as e:
return server_error_response(e)
@router.post("/update")
async def update(
request: UpdateMCPRequest,
current_user: User = Depends(get_current_user)
request: UpdateMCPServerRequest,
current_user = Depends(get_current_user)
):
"""更新MCP服务器"""
mcp_id = request.mcp_id
e, mcp_server = MCPServerService.get_by_id(mcp_id)
if not e or mcp_server.tenant_id != current_user.id:
return get_data_error_result(message=f"Cannot find MCP server {mcp_id} for user {current_user.id}")
server_type = request.server_type or mcp_server.server_type
server_type = request.server_type if request.server_type is not None else mcp_server.server_type
if server_type and server_type not in VALID_MCP_SERVER_TYPES:
return get_data_error_result(message="Unsupported MCP server type.")
server_name = request.name or mcp_server.name
server_name = request.name if request.name is not None else mcp_server.name
if server_name and len(server_name.encode("utf-8")) > 255:
return get_data_error_result(message=f"Invalid MCP name or length is {len(server_name)} which is large than 255.")
url = request.url or mcp_server.url
url = request.url if request.url is not None else mcp_server.url
if not url:
return get_data_error_result(message="Invalid url.")
headers = safe_json_parse(request.headers or mcp_server.headers)
variables = safe_json_parse(request.variables or mcp_server.variables)
headers = safe_json_parse(request.headers if request.headers is not None else mcp_server.headers)
variables = safe_json_parse(request.variables if request.variables is not None else mcp_server.variables)
variables.pop("tools", None)
timeout = request.timeout or 10
timeout = request.timeout or 10.0
try:
req_data = {
req = {
"tenant_id": current_user.id,
"id": mcp_id,
"name": server_name,
@@ -291,7 +188,6 @@ async def update(
"server_type": server_type,
"headers": headers,
"variables": variables,
"timeout": timeout
}
mcp_server = MCPServer(id=server_name, name=server_name, url=url, server_type=server_type, variables=variables, headers=headers)
@@ -302,12 +198,12 @@ async def update(
tools = server_tools[server_name]
tools = {tool["name"]: tool for tool in tools if isinstance(tool, dict) and "name" in tool}
variables["tools"] = tools
req_data["variables"] = variables
req["variables"] = variables
if not MCPServerService.filter_update([MCPServer.id == mcp_id, MCPServer.tenant_id == current_user.id], req_data):
if not MCPServerService.filter_update([MCPServer.id == mcp_id, MCPServer.tenant_id == current_user.id], req):
return get_data_error_result(message="Failed to updated MCP server.")
e, updated_mcp = MCPServerService.get_by_id(req_data["id"])
e, updated_mcp = MCPServerService.get_by_id(req["id"])
if not e:
return get_data_error_result(message="Failed to fetch updated MCP server.")
@@ -318,9 +214,10 @@ async def update(
@router.post("/rm")
async def rm(
request: RemoveMCPRequest,
current_user: User = Depends(get_current_user)
request: DeleteMCPServersRequest,
current_user = Depends(get_current_user)
):
"""删除MCP服务器"""
mcp_ids = request.mcp_ids
try:
@@ -334,14 +231,15 @@ async def rm(
@router.post("/import")
async def import_multiple(
request: ImportMCPRequest,
current_user: User = Depends(get_current_user)
request: ImportMCPServersRequest,
current_user = Depends(get_current_user)
):
"""批量导入MCP服务器"""
servers = request.mcpServers
if not servers:
return get_data_error_result(message="No MCP servers provided.")
timeout = request.timeout or 10
timeout = request.timeout or 10.0
results = []
try:
@@ -401,9 +299,10 @@ async def import_multiple(
@router.post("/export")
async def export_multiple(
request: ExportMCPRequest,
current_user: User = Depends(get_current_user)
request: ExportMCPServersRequest,
current_user = Depends(get_current_user)
):
"""批量导出MCP服务器"""
mcp_ids = request.mcp_ids
if not mcp_ids:
@@ -432,12 +331,16 @@ async def export_multiple(
@router.post("/list_tools")
async def list_tools(req: ListToolsRequest, current_user: User = Depends(get_current_user)):
mcp_ids = req.mcp_ids
async def list_tools(
request: ListMCPToolsRequest,
current_user = Depends(get_current_user)
):
"""列出MCP工具"""
mcp_ids = request.mcp_ids
if not mcp_ids:
return get_data_error_result(message="No MCP server IDs provided.")
timeout = req.timeout
timeout = request.timeout or 10.0
results = {}
tool_call_sessions = []
@@ -476,15 +379,19 @@ async def list_tools(req: ListToolsRequest, current_user: User = Depends(get_cur
@router.post("/test_tool")
async def test_tool(req: TestToolRequest, current_user: User = Depends(get_current_user)):
mcp_id = req.mcp_id
async def test_tool(
request: TestMCPToolRequest,
current_user = Depends(get_current_user)
):
"""测试MCP工具"""
mcp_id = request.mcp_id
if not mcp_id:
return get_data_error_result(message="No MCP server ID provided.")
timeout = req.timeout
timeout = request.timeout or 10.0
tool_name = req.tool_name
arguments = req.arguments
tool_name = request.tool_name
arguments = request.arguments
if not all([tool_name, arguments]):
return get_data_error_result(message="Require provide tool name and arguments.")
@@ -506,11 +413,15 @@ async def test_tool(req: TestToolRequest, current_user: User = Depends(get_curre
@router.post("/cache_tools")
async def cache_tool(req: CacheToolsRequest, current_user: User = Depends(get_current_user)):
mcp_id = req.mcp_id
async def cache_tool(
request: CacheMCPToolsRequest,
current_user = Depends(get_current_user)
):
"""缓存MCP工具"""
mcp_id = request.mcp_id
if not mcp_id:
return get_data_error_result(message="No MCP server ID provided.")
tools = req.tools
tools = request.tools
e, mcp_server = MCPServerService.get_by_id(mcp_id)
if not e or mcp_server.tenant_id != current_user.id:
@@ -527,18 +438,21 @@ async def cache_tool(req: CacheToolsRequest, current_user: User = Depends(get_cu
@router.post("/test_mcp")
async def test_mcp(req: TestMCPRequest):
url = req.url
async def test_mcp(
request: TestMCPRequest
):
"""测试MCP服务器（不需要登录）"""
url = request.url
if not url:
return get_data_error_result(message="Invalid MCP url.")
server_type = req.server_type
server_type = request.server_type
if server_type not in VALID_MCP_SERVER_TYPES:
return get_data_error_result(message="Unsupported MCP server type.")
timeout = req.timeout
headers = req.headers
variables = req.variables
timeout = request.timeout or 10.0
headers = safe_json_parse(request.headers or {})
variables = safe_json_parse(request.variables or {})
mcp_server = MCPServer(id=f"{server_type}: {url}", server_type=server_type, url=url, headers=headers, variables=variables)