lightpdf-aipdf-backend 0.1.1__tar.gz

lightpdf_aipdf_backend-0.1.1/.env

@@ -0,0 +1,7 @@
+# OPENAI_API_KEY=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
+# OPENAI_BASE_URL=https://openai-api.aoscdn.com/v1
+# OPENAI_MODEL=gpt-4o-mini
+OPENAI_API_KEY=sk-04c4fd40cbc34de5a7858cb723b89067
+OPENAI_BASE_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
+OPENAI_MODEL=qwen-turbo
+API_KEY=wx6ce6ckkey17wany

lightpdf_aipdf_backend-0.1.1/.gitignore

@@ -0,0 +1,20 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv/
+node_modules/
+
+# macOS system files
+.DS_Store
+
+mcp_server/demo/
+mcp_server/docs/
+homepage/backend/uploads
+.version
+lightpdf-mcp.zip

lightpdf_aipdf_backend-0.1.1/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: lightpdf-aipdf-backend
+Version: 0.1.1
+Summary: Backend API for LightPDF AI-PDF
+License: Proprietary
+Requires-Python: >=3.9
+Requires-Dist: fastapi
+Requires-Dist: mcp[cli]
+Requires-Dist: openai
+Requires-Dist: pydantic
+Requires-Dist: python-dotenv
+Requires-Dist: python-multipart
+Requires-Dist: uvicorn
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# LightPDF AI-PDF Backend
+
+这是LightPDF AI-PDF的后端API服务。
+
+## 安装
+
+使用uv安装：
+
+```bash
+uv pip install -e .
+```
+
+或者构建并安装：
+
+```bash
+uv build
+uv pip install dist/*.whl
+```
+
+## 配置
+
+有两种配置方式：
+
+### 1. 使用.env文件（开发环境）
+
+创建一个`.env`文件，包含以下环境变量：
+
+```
+OPENAI_API_KEY=your_openai_api_key
+OPENAI_MODEL=gpt-4o-mini
+OPENAI_BASE_URL=https://api.openai.com/v1
+# 其他必要的环境变量
+```
+
+注意：`.env`文件不会包含在构建包中，需要在部署环境中手动创建。
+
+### 2. 使用环境变量（生产环境）
+
+直接设置环境变量：
+
+```bash
+export OPENAI_API_KEY=your_openai_api_key
+export OPENAI_MODEL=gpt-4o-mini
+export OPENAI_BASE_URL=https://api.openai.com/v1
+# 设置其他必要的环境变量
+```
+
+## 使用方法
+
+安装后，可以通过以下命令启动服务器：
+
+```bash
+lightpdf-aipdf-server
+```
+
+也可以作为模块运行：
+
+```bash
+python -m lightpdf_aipdf_backend
+```
+
+## 开发
+
+安装开发依赖：
+
+```bash
+uv pip install -e ".[dev]"
+```

lightpdf_aipdf_backend-0.1.1/README.md

@@ -0,0 +1,68 @@
+# LightPDF AI-PDF Backend
+
+这是LightPDF AI-PDF的后端API服务。
+
+## 安装
+
+使用uv安装：
+
+```bash
+uv pip install -e .
+```
+
+或者构建并安装：
+
+```bash
+uv build
+uv pip install dist/*.whl
+```
+
+## 配置
+
+有两种配置方式：
+
+### 1. 使用.env文件（开发环境）
+
+创建一个`.env`文件，包含以下环境变量：
+
+```
+OPENAI_API_KEY=your_openai_api_key
+OPENAI_MODEL=gpt-4o-mini
+OPENAI_BASE_URL=https://api.openai.com/v1
+# 其他必要的环境变量
+```
+
+注意：`.env`文件不会包含在构建包中，需要在部署环境中手动创建。
+
+### 2. 使用环境变量（生产环境）
+
+直接设置环境变量：
+
+```bash
+export OPENAI_API_KEY=your_openai_api_key
+export OPENAI_MODEL=gpt-4o-mini
+export OPENAI_BASE_URL=https://api.openai.com/v1
+# 设置其他必要的环境变量
+```
+
+## 使用方法
+
+安装后，可以通过以下命令启动服务器：
+
+```bash
+lightpdf-aipdf-server
+```
+
+也可以作为模块运行：
+
+```bash
+python -m lightpdf_aipdf_backend
+```
+
+## 开发
+
+安装开发依赖：
+
+```bash
+uv pip install -e ".[dev]"
+```

lightpdf_aipdf_backend-0.1.1/publish.sh

@@ -0,0 +1,160 @@
+#!/bin/bash
+
+# 显示帮助信息
+show_help() {
+    echo "用法: $0 [-p|--publish] [版本号]"
+    echo
+    echo "参数:"
+    echo "  -p, --publish    执行发布操作（同时会更新版本号）"
+    echo "  版本号           指定新的版本号（可选，格式：x.y.z，仅在发布时有效）"
+    echo
+    echo "示例:"
+    echo "  $0              # 仅构建，使用版本号0.0.1"
+    echo "  $0 1.0.0        # 仅构建，使用版本号0.0.1"
+    echo "  $0 -p           # 构建并发布，自动递增版本号"
+    echo "  $0 -p 1.0.0     # 构建并发布，使用指定版本号"
+}
+
+# 解析命令行参数
+PUBLISH=false
+VERSION=""
+VERSION_FILE=".version"
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        -p|--publish)
+            PUBLISH=true
+            shift
+            ;;
+        -h|--help)
+            show_help
+            exit 0
+            ;;
+        *)
+            if [[ -z "$VERSION" ]]; then
+                VERSION="$1"
+            else
+                echo "错误: 无效的参数 '$1'"
+                show_help
+                exit 1
+            fi
+            shift
+            ;;
+    esac
+done
+
+# 检查是否安装了必要的工具
+if ! command -v uv &> /dev/null; then
+    echo "错误: 未找到 uv 命令，请先安装 uv"
+    exit 1
+fi
+
+if ! command -v sed &> /dev/null; then
+    echo "错误: 未找到 sed 命令"
+    exit 1
+fi
+
+# 激活虚拟环境
+# if [ -d ".venv" ]; then
+#     echo "正在激活虚拟环境..."
+#     source .venv/bin/activate
+#     if [ $? -ne 0 ]; then
+#         echo "错误: 虚拟环境激活失败"
+#         exit 1
+#     fi
+# else
+#     echo "错误: 未找到虚拟环境(.venv目录)"
+#     exit 1
+# fi
+
+if [ "$PUBLISH" = true ]; then
+    # 读取或创建版本文件
+    if [ ! -f "$VERSION_FILE" ]; then
+        echo "0.1.0" > "$VERSION_FILE"
+    fi
+    current_version=$(cat "$VERSION_FILE")
+    echo "当前版本: $current_version"
+
+    # 确定新版本号
+    if [ -n "$VERSION" ]; then
+        # 如果提供了版本号参数，使用该版本号
+        new_version="$VERSION"
+        echo "使用指定版本: $new_version"
+    else
+        # 如果没有提供版本号，递增当前版本的修订号
+        IFS='.' read -r major minor patch <<< "$current_version"
+        new_patch=$((patch + 1))
+        new_version="$major.$minor.$new_patch"
+        echo "自动递增版本: $new_version"
+    fi
+
+    # 验证版本号格式
+    if ! [[ $new_version =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+        echo "错误: 无效的版本号格式。版本号必须是 x.y.z 格式，其中 x、y、z 都是数字"
+        exit 1
+    fi
+
+    # 更新版本文件
+    echo "$new_version" > "$VERSION_FILE"
+    echo "版本文件已更新"
+
+    # 更新pyproject.toml中的版本号
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        # macOS
+        sed -i '' "s/^version = \".*\"/version = \"$new_version\"/" pyproject.toml
+    else
+        # Linux
+        sed -i "s/^version = \".*\"/version = \"$new_version\"/" pyproject.toml
+    fi
+else
+    # 非发布模式，使用固定版本号0.0.1
+    new_version="0.0.1"
+    echo "使用开发版本: $new_version"
+    
+    # 更新pyproject.toml中的版本号（不更新版本文件）
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        # macOS
+        sed -i '' "s/^version = \".*\"/version = \"$new_version\"/" pyproject.toml
+    else
+        # Linux
+        sed -i "s/^version = \".*\"/version = \"$new_version\"/" pyproject.toml
+    fi
+fi
+
+# 删除旧包
+echo "正在删除旧包..."
+rm -rf dist/*
+rm -rf build/*
+
+# 构建包
+echo "正在构建包..."
+uv build
+
+# 检查构建是否成功
+if [ $? -ne 0 ]; then
+    echo "错误: 构建失败"
+    exit 1
+fi
+
+# 如果指定了发布标志，则执行发布
+if [ "$PUBLISH" = true ]; then
+    # 设置环境变量
+    export UV_PUBLISH_URL=https://upload.pypi.org/legacy/
+    export UV_PUBLISH_TOKEN=pypi-AgEIcHlwaS5vcmcCJDNhZjM3NGUzLTc0OTItNDU5MC1iNWYxLTQ2Yjc5MDNmOTkzMgACKlszLCJmOGZmOWJlOS02M2M1LTRiZmYtOTllZS1mMjRkYjEyMGE0ZGUiXQAABiCcCvNSctcaY_DWzZx9ShYEjtMqIdiyHkWBvGhc9vmPAg
+
+    echo "正在发布包..."
+    uv publish
+
+    # 检查发布是否成功
+    if [ $? -ne 0 ]; then
+        echo "错误: 发布失败"
+        exit 1
+    fi
+    echo "发布成功！新版本: $new_version"
+else
+    echo "构建成功！新版本: $new_version"
+    echo "提示: 使用 -p 或 --publish 参数来执行发布"
+fi
+
+# 退出虚拟环境
+# deactivate 

lightpdf_aipdf_backend-0.1.1/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "lightpdf-aipdf-backend"
+version = "0.1.1"
+description = "Backend API for LightPDF AI-PDF"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "Proprietary" }
+dependencies = [
+    "fastapi",
+    "uvicorn",
+    "python-dotenv",
+    "openai",
+    "mcp[cli]",
+    "pydantic",
+    "python-multipart",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "black",
+    "isort",
+]
+
+[project.scripts]
+lightpdf-aipdf-server = "lightpdf_aipdf_backend.cli:run_server"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lightpdf_aipdf_backend"]
+exclude = [".env", "*.log", "uploads/*"]
+
+[tool.black]
+line-length = 88
+
+[tool.isort]
+profile = "black"

lightpdf_aipdf_backend-0.1.1/run.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python
+"""
+快速启动后端服务的脚本
+在开发期间可直接运行此脚本启动服务
+"""
+import asyncio
+from src.lightpdf_aipdf_backend.main import main
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

lightpdf_aipdf_backend-0.1.1/setup.py

@@ -0,0 +1,7 @@
+"""
+兼容性setup.py文件
+"""
+from setuptools import setup
+
+if __name__ == "__main__":
+    setup() 

lightpdf_aipdf_backend-0.1.1/src/lightpdf_aipdf_backend/__init__.py

@@ -0,0 +1,3 @@
+"""LightPDF AI-PDF Backend Package"""
+
+__version__ = "0.1.0"

lightpdf_aipdf_backend-0.1.1/src/lightpdf_aipdf_backend/__main__.py

@@ -0,0 +1,8 @@
+"""
+后端应用主入口模块
+"""
+import asyncio
+from .main import main
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

lightpdf_aipdf_backend-0.1.1/src/lightpdf_aipdf_backend/app.py

@@ -0,0 +1,58 @@
+from fastapi import FastAPI, Depends, HTTPException, File, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from contextlib import asynccontextmanager
+
+from .models import ChatRequest
+from .file_handler import handle_file_upload
+from .chat_handler import process_messages, generate_chat_response
+from .utils import async_generator_to_json_stream
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """应用生命周期管理"""
+    # 应用启动时的初始化
+    yield
+    # 应用关闭时的清理
+
+# 创建FastAPI应用
+app = FastAPI(title="LightPDF AI助手API", lifespan=lifespan)
+
+# 配置CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # 在生产环境中应该限制为特定域名
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+async def root():
+    """API根路径"""
+    return {"message": "LightPDF AI助手 API已启动"}
+
+@app.post("/api/upload")
+async def upload_file(file: UploadFile = File(...)):
+    """处理文件上传请求"""
+    return await handle_file_upload(file)
+
+@app.post("/api/chat")
+async def chat(request: ChatRequest):
+    """处理聊天请求"""
+    try:
+        # 处理消息
+        processed_messages = await process_messages(request.messages)
+        
+        # 生成响应 - 修改响应头部，确保流式内容不被缓存或批处理
+        return StreamingResponse(
+            async_generator_to_json_stream(generate_chat_response(processed_messages)),
+            media_type="application/x-ndjson",
+            headers={
+                "Cache-Control": "no-cache, no-transform",
+                "X-Accel-Buffering": "no"  # 禁用Nginx缓冲
+            }
+        )
+    except Exception as e:
+        error_msg = str(e)
+        raise HTTPException(status_code=500, detail=f"LightPDF AI助手处理错误: {error_msg}") 

lightpdf_aipdf_backend-0.1.1/src/lightpdf_aipdf_backend/chat_handler.py

@@ -0,0 +1,298 @@
+import json
+from typing import List, Dict, AsyncGenerator, Any, Tuple
+from fastapi import HTTPException
+
+from .state import get_openai_client, get_session_history, update_session_history, reset_session_history, get_mcp_session
+from .models import Message
+from .file_handler import get_file_references
+from .tools import get_tools, format_tool_response, process_tool_path
+from .utils import validate_and_fix_messages, async_generator_to_json_stream
+from .config import Config
+
+async def handle_tool_call(tool_call: Any, api_messages: List[Dict]) -> Tuple[Dict, Dict]:
+    """处理单个工具调用
+    
+    Args:
+        tool_call: 工具调用对象
+        api_messages: API消息列表
+    
+    Returns:
+        Tuple[Dict, Dict]: 工具响应消息和yield消息
+    """
+    tool_name = tool_call.function.name
+    tool_args = json.loads(tool_call.function.arguments)
+    tool_args = await process_tool_path(tool_args)
+    
+    try:
+        mcp_session = get_mcp_session()
+        tool_response = await mcp_session.call_tool(tool_name, tool_args)
+        formatted_response = format_tool_response(tool_response.model_dump())
+        
+        tool_response_message = {
+            "role": "tool",
+            "tool_call_id": tool_call.id,
+            "name": tool_name,
+            "content": formatted_response
+        }
+        
+        yield_message = {
+            "type": "step",
+            "step_type": "result",
+            "content": formatted_response
+        }
+        
+    except Exception as e:
+        error_msg = str(e)
+        tool_response_message = {
+            "role": "tool",
+            "tool_call_id": tool_call.id,
+            "name": tool_name,
+            "content": f"Error: {error_msg}"
+        }
+        
+        yield_message = {
+            "type": "error",
+            "content": f"工具 {tool_name} 调用失败：{error_msg}"
+        }
+    
+    return tool_response_message, yield_message
+
+async def collect_stream_content(response: Any) -> AsyncGenerator[Dict, Tuple[str, str, List[Dict]]]:
+    """收集流式响应内容
+    
+    Args:
+        response: OpenAI流式响应对象
+    
+    Yields:
+        Dict: 处理后的消息
+        
+    Returns:
+        Tuple[str, str, List[Dict]]: 完整内容、完成原因和工具调用数据
+    """
+    full_content = ""
+    finish_reason = None
+    tool_calls_data = []
+    
+    for chunk in response:
+        choice = chunk.choices[0]
+        delta = choice.delta
+        
+        if delta.content:
+            full_content += delta.content
+            yield {
+                "type": "stream_chunk",
+                "content": delta.content
+            }
+        
+        if delta.tool_calls:
+            for tool_call_delta in delta.tool_calls:
+                tc_index = tool_call_delta.index
+                while len(tool_calls_data) <= (tc_index or 0):
+                    tool_calls_data.append({"id": None, "type": "function", "function": {"name": "", "arguments": ""}})
+                
+                tc_data = tool_calls_data[tc_index]
+                if tool_call_delta.id:
+                    tc_data.update({"id": tool_call_delta.id})
+                
+                tc_function = tool_call_delta.function
+                if tc_function:
+                    current_tool = tc_data["function"]
+                    if tc_function.name:
+                        current_tool["name"] = tc_function.name
+                    if tc_function.arguments:
+                        current_tool["arguments"] = current_tool.get("arguments", "") + tc_function.arguments
+        
+        if choice.finish_reason:
+            finish_reason = choice.finish_reason
+    
+    yield (full_content, finish_reason, tool_calls_data)  # 替换return，作为最后一个yield值
+
+async def process_messages(messages: List[Message]) -> List[Dict]:
+    """处理消息列表，包括文件处理和格式转换
+    
+    Args:
+        messages: 消息列表
+        
+    Returns:
+        List[Dict]: 处理后的消息列表
+    """
+    # 检查是否是新会话
+    is_new_session = len(messages) <= 2  # 通常新会话只有系统消息和用户消息
+    session_history = get_session_history()
+    
+    if is_new_session:
+        reset_session_history()
+    
+    # 转换消息并处理文件
+    processed_messages = []
+    
+    # 如果有会话历史且不是新会话，优先使用会话历史
+    if session_history and not is_new_session:
+        # 添加会话历史中的消息
+        processed_messages.extend(session_history)
+        
+        # 只处理会话历史之后的新消息
+        new_messages = messages[len(session_history):]
+    else:
+        new_messages = messages
+    
+    for msg in new_messages:
+        # 基本消息结构
+        message_dict = {"role": msg.role, "content": msg.content}
+        
+        # 处理assistant角色的工具调用
+        if msg.role == "assistant" and msg.tool_calls:
+            message_dict["tool_calls"] = msg.tool_calls
+            # 当有工具调用时，content可以为空字符串
+            if not message_dict["content"]:
+                message_dict["content"] = ""
+        
+        # 处理tool角色的工具响应
+        if msg.role == "tool":
+            if msg.tool_call_id:
+                message_dict["tool_call_id"] = msg.tool_call_id
+            if msg.name:
+                message_dict["name"] = msg.name
+            # 确保tool角色必须有tool_call_id和name
+            if "tool_call_id" not in message_dict or "name" not in message_dict:
+                continue
+        
+        # 如果消息包含文件ID
+        if msg.file_ids:
+            file_urls = get_file_references(msg.file_ids)
+            
+            # 将文件引用添加到消息内容
+            if file_urls:
+                message_dict["content"] += "\n\n以下是文件附件的Markdown链接:\n\n" + "\n".join(file_urls)
+        
+        processed_messages.append(message_dict)
+    
+    # 限制消息历史长度
+    MAX_MESSAGES = 50  # 增加消息历史长度以保留工具调用上下文
+    if len(processed_messages) > MAX_MESSAGES:
+        processed_messages = processed_messages[-MAX_MESSAGES:]
+    
+    # 检查工具调用和响应的匹配
+    return validate_and_fix_messages(processed_messages)
+
+async def generate_chat_response(messages: List[Dict]) -> AsyncGenerator:
+    """生成聊天响应
+    
+    Args:
+        messages: 处理后的消息列表
+        
+    Yields:
+        Dict: 响应内容
+    """
+    openai_client = get_openai_client()
+    
+    try:
+        tools = await get_tools()
+
+        api_messages = messages.copy()
+        while True:
+            # 第一次调用API使用流式请求
+            response = openai_client.chat.completions.create(
+                model=Config.MODEL_NAME,
+                temperature=0.4,
+                messages=api_messages,
+                tools=tools,
+                parallel_tool_calls=False,
+                stream=True
+            )
+            
+            full_content = ""
+            finish_reason = None
+            tool_calls_data = []
+            yield_content = False
+            # 收集流式响应内容
+            async for item in collect_stream_content(response):
+                if isinstance(item, tuple):
+                    full_content, finish_reason, tool_calls_data = item
+                else:
+                    if not yield_content:
+                        # 第一次消息通知
+                        yield {
+                            "type": "stream_start",
+                            "content": ""
+                        }
+                        yield_content = True
+                    
+                    yield item
+            
+            # 如果需要调用工具
+            if finish_reason == 'tool_calls' and tool_calls_data:
+                if yield_content:
+                    # 停止当前流
+                    yield {
+                        "type": "stream_end",
+                        "content": full_content
+                    }
+                
+                # 转换工具调用格式并创建消息
+                tool_calls = []
+                for tc_data in tool_calls_data:
+                    tc_function = tc_data["function"]
+                    if tc_data["id"] and tc_function["name"]:
+                        tool_calls.append(type('ToolCall', (), {
+                            'id': tc_data["id"],
+                            'function': type('Function', (), {
+                                'name': tc_function["name"],
+                                'arguments': tc_function["arguments"]
+                            })
+                        }))
+                
+                # 创建助手消息
+                assistant_message = {
+                    "role": "assistant",
+                    "content": full_content or "",
+                    "tool_calls": [
+                        {
+                            "id": tc.id,
+                            "type": "function",
+                            "function": {
+                                "name": tc.function.name,
+                                "arguments": tc.function.arguments
+                            }
+                        } for tc in tool_calls
+                    ]
+                }
+                
+                # 准备API消息列表
+                api_messages.append(assistant_message)
+                
+                # 处理每个工具调用
+                for tool_call in tool_calls:
+                    # 发送工具调用信息
+                    yield {
+                        "type": "step",
+                        "step_type": "call",
+                        "content": f"调用工具 {tool_call.function.name}\n参数：{tool_call.function.arguments}"
+                    }
+                    
+                    # 处理工具调用
+                    tool_response_message, yield_message = await handle_tool_call(tool_call, api_messages)
+                    api_messages.append(tool_response_message)
+                    yield yield_message
+                
+            else:
+                # 如果不需要调用工具，直接结束流
+                yield {
+                    "type": "stream_end",
+                    "content": full_content
+                }
+                
+                # 更新会话历史
+                api_messages.append({
+                    "role": "assistant",
+                    "content": full_content
+                })
+                update_session_history(api_messages)
+
+                break
+
+    except Exception as e:
+        yield {
+            "type": "error",
+            "content": str(e)
+        } 

lightpdf_aipdf_backend-0.1.1/src/lightpdf_aipdf_backend/cli.py

@@ -0,0 +1,9 @@
+"""
+CLI命令入口
+"""
+import asyncio
+from .main import main
+
+def run_server():
+    """运行API服务器的命令行入口点"""
+    asyncio.run(main()) 

lightpdf_aipdf_backend-0.1.1/src/lightpdf_aipdf_backend/config.py

@@ -0,0 +1,22 @@
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+# 加载环境变量
+load_dotenv()
+
+# 文件上传目录
+UPLOADS_DIR = Path("uploads")
+UPLOADS_DIR.mkdir(exist_ok=True)
+
+class Config:
+    """应用配置类"""
+    MODEL_NAME = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+    BASE_URL = os.getenv("OPENAI_BASE_URL")
+    API_KEY = os.getenv("OPENAI_API_KEY")
+    
+    @classmethod
+    def validate(cls):
+        """验证关键配置项"""
+        if not cls.API_KEY:
+            raise ValueError("Missing OpenAI API Key") 

lightpdf_aipdf_backend-0.1.1/src/lightpdf_aipdf_backend/file_handler.py

@@ -0,0 +1,81 @@
+import os
+import shutil
+from uuid import uuid4
+from fastapi import UploadFile, HTTPException
+from pathlib import Path
+
+from .config import UPLOADS_DIR
+from .models import FileInfo
+from .state import uploaded_files
+
+async def handle_file_upload(file: UploadFile) -> FileInfo:
+    """处理文件上传请求
+    
+    Args:
+        file: 上传的文件
+        
+    Returns:
+        FileInfo: 文件信息对象
+        
+    Raises:
+        HTTPException: 文件上传失败时抛出
+    """
+    # 生成唯一文件名
+    file_id = str(uuid4())
+    filename = file.filename or "unknown_file"
+    content_type = file.content_type or "application/octet-stream"
+    
+    # 确保文件名安全
+    safe_filename = f"{file_id}_{filename}"
+    file_path = UPLOADS_DIR / safe_filename
+    
+    # 确保UPLOADS_DIR存在
+    UPLOADS_DIR.mkdir(exist_ok=True)
+    
+    # 保存文件
+    try:
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+        
+        # 使用相对路径(仅文件名)
+        relative_path = safe_filename
+        
+        # 创建文件信息
+        file_info = FileInfo(
+            file_id=file_id,
+            filename=filename,
+            content_type=content_type,
+            path=relative_path
+        )
+        
+        # 存储文件信息
+        uploaded_files[file_id] = file_info
+        
+        return file_info
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"文件上传失败: {str(e)}")
+
+def get_file_references(file_ids: list[str]) -> list[str]:
+    """获取文件引用链接
+    
+    Args:
+        file_ids: 文件ID列表
+        
+    Returns:
+        list[str]: 文件引用链接列表
+    """
+    file_urls = []
+    
+    for file_id in file_ids:
+        if file_id in uploaded_files:
+            file_info = uploaded_files[file_id]
+            # 检查文件是否存在
+            file_path = os.path.join(UPLOADS_DIR, file_info.path) if not os.path.isabs(file_info.path) else file_info.path
+            if os.path.exists(file_path):
+                # 根据文件类型添加不同的引用格式
+                if file_info.content_type.startswith("image/"):
+                    file_urls.append(f"![图片: {file_info.filename}]({file_info.path})")
+                else:
+                    file_urls.append(f"[文件: {file_info.filename}]({file_info.path})")
+    
+    return file_urls 

lightpdf_aipdf_backend-0.1.1/src/lightpdf_aipdf_backend/main.py

@@ -0,0 +1,45 @@
+import os
+import asyncio
+import uvicorn
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from .config import Config, UPLOADS_DIR
+from .state import set_mcp_session, init_openai_client
+from .app import app
+from .tools import get_tools
+
+async def main():
+    """应用主入口"""
+    # 初始化 OpenAI 客户端
+    init_openai_client()
+    
+    # 准备 MCP 服务参数
+    server_params = StdioServerParameters(
+        command="uvx",
+        args=["mcp_lightpdf@latest"],
+        # args=["-n", "--from", "../../../mcp_server/dist/mcp_lightpdf-0.0.1-py3-none-any.whl", "mcp_lightpdf"],
+        cwd=UPLOADS_DIR,
+        env={
+            "API_KEY": os.getenv("API_KEY"),
+        }
+    )
+    
+    # 启动 MCP 会话
+    async with stdio_client(server_params) as (read, write):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+            # 设置全局 MCP 会话
+            set_mcp_session(session)
+
+            tools = await get_tools()
+            print(tools)
+            
+            # 启动 FastAPI 服务器
+            config = uvicorn.Config(app, port=3300)
+            server = uvicorn.Server(config)
+            await server.serve()
+
+# 确保与原始 main 函数相同
+if __name__ == "__main__":
+    asyncio.run(main()) 

lightpdf_aipdf_backend-0.1.1/src/lightpdf_aipdf_backend/models.py

@@ -0,0 +1,22 @@
+from typing import List, Optional, Dict
+from pydantic import BaseModel
+
+class FileInfo(BaseModel):
+    """文件信息模型"""
+    file_id: str
+    filename: str
+    content_type: str
+    path: str
+
+class Message(BaseModel):
+    """聊天消息模型"""
+    role: str
+    content: str
+    file_ids: Optional[List[str]] = None
+    tool_calls: Optional[List[Dict]] = None
+    tool_call_id: Optional[str] = None
+    name: Optional[str] = None
+
+class ChatRequest(BaseModel):
+    """聊天请求模型"""
+    messages: List[Message] 

lightpdf_aipdf_backend-0.1.1/src/lightpdf_aipdf_backend/state.py

@@ -0,0 +1,53 @@
+from typing import Dict, List, Optional, Any
+from collections import defaultdict
+from openai import OpenAI
+from mcp import ClientSession
+
+from .config import Config
+
+# 全局变量
+mcp_session: Optional[ClientSession] = None
+openai_client: Optional[OpenAI] = None
+active_conversations = defaultdict(lambda: {"messages": [], "generator": None})
+session_history: List[Dict] = []
+uploaded_files: Dict[str, Any] = {}
+
+def init_openai_client():
+    """初始化OpenAI客户端"""
+    global openai_client
+    Config.validate()
+    openai_client = OpenAI(
+        api_key=Config.API_KEY,
+        base_url=Config.BASE_URL
+    )
+    return openai_client
+
+def get_openai_client() -> OpenAI:
+    """获取OpenAI客户端实例"""
+    global openai_client
+    if openai_client is None:
+        openai_client = init_openai_client()
+    return openai_client
+
+def set_mcp_session(session: ClientSession):
+    """设置MCP会话"""
+    global mcp_session
+    mcp_session = session
+
+def get_mcp_session() -> Optional[ClientSession]:
+    """获取MCP会话"""
+    return mcp_session
+
+def reset_session_history():
+    """重置会话历史"""
+    global session_history
+    session_history = []
+
+def get_session_history() -> List[Dict]:
+    """获取会话历史"""
+    return session_history
+
+def update_session_history(history: List[Dict]):
+    """更新会话历史"""
+    global session_history
+    session_history = history 

lightpdf_aipdf_backend-0.1.1/src/lightpdf_aipdf_backend/tools.py

@@ -0,0 +1,96 @@
+import os
+import json
+from typing import List, Dict, Any
+from fastapi import HTTPException
+
+from .state import get_mcp_session
+
+async def get_tools() -> List[Dict]:
+    """从MCP client获取工具列表
+    
+    Returns:
+        List[Dict]: 工具列表
+        
+    Raises:
+        HTTPException: MCP会话未初始化时抛出
+    """
+    mcp_session = get_mcp_session()
+    if not mcp_session:
+        raise HTTPException(status_code=500, detail="MCP session not initialized")
+    
+    tools_result = await mcp_session.list_tools()
+    tools = []
+    
+    for tool in tools_result.tools:
+        tool_dict = {
+            "type": "function",
+            "function": {
+                "name": tool.name,
+                "description": tool.description,
+                "parameters": tool.inputSchema
+            }
+        }
+        tools.append(tool_dict)
+    return tools
+
+def format_tool_response(response_dict: Dict) -> str:
+    """格式化工具响应，提取可能包含的Markdown内容
+    
+    Args:
+        response_dict: 工具响应字典
+        
+    Returns:
+        str: 格式化后的响应
+    """
+    print(response_dict)
+    # 如果有 content 字段，优先使用它
+    if 'content' in response_dict:
+        return response_dict['content']
+    
+    # 如果有 markdown 字段，优先使用它
+    if 'markdown' in response_dict:
+        return response_dict['markdown']
+    
+    # 检查是否有返回文本字段
+    if 'text' in response_dict:
+        return response_dict['text']
+    
+    # 如果有结果字段，检查是否包含Markdown内容
+    if 'result' in response_dict:
+        result = response_dict['result']
+        if isinstance(result, dict):
+            # 优先查找markdown字段
+            if 'markdown' in result:
+                return result['markdown']
+            elif 'text' in result:
+                return result['text']
+            elif 'content' in result:
+                return result['content']
+    
+    # 否则返回格式化的JSON
+    return f"工具返回结果：\n```json\n{json.dumps(response_dict, ensure_ascii=False, indent=2)}\n```"
+
+async def process_tool_path(tool_args: Dict) -> Dict:
+    """处理工具调用参数中的文件路径
+    
+    Args:
+        tool_args: 工具调用参数
+        
+    Returns:
+        Dict: 处理后的参数
+    """
+    if 'file_path' in tool_args:
+        from .config import UPLOADS_DIR  # 避免循环导入
+        
+        file_path = tool_args['file_path']
+        # 尝试确保文件路径正确
+        if not os.path.exists(file_path):
+            file_name = os.path.basename(file_path)
+            # 在uploads目录中查找
+            for uploaded_file in os.listdir(UPLOADS_DIR):
+                if file_name in uploaded_file:
+                    full_path = os.path.join(UPLOADS_DIR, uploaded_file)
+                    tool_args['file_path'] = full_path
+                    break
+    
+    return tool_args 

lightpdf_aipdf_backend-0.1.1/src/lightpdf_aipdf_backend/utils.py

@@ -0,0 +1,52 @@
+import json
+from typing import Dict, List, AsyncGenerator, Any
+
+def validate_and_fix_messages(messages: List[Dict]) -> List[Dict]:
+    """验证并修复消息格式，确保工具调用和响应的匹配
+    
+    Args:
+        messages: 消息列表
+        
+    Returns:
+        List[Dict]: 修复后的消息列表
+    """
+    if not messages:
+        return []
+    
+    fixed_messages = []
+    tool_call_ids = {}  # 用于跟踪工具调用ID及其对应的工具名称
+    
+    for msg in messages:
+        # 检查assistant角色的工具调用
+        if msg["role"] == "assistant" and "tool_calls" in msg:
+            # 存储工具调用ID和对应的工具名称
+            for tool_call in msg["tool_calls"]:
+                tool_call_ids[tool_call["id"]] = tool_call["function"]["name"]
+        
+        # 处理tool角色的响应，确保有对应的tool_call_id和name
+        if msg["role"] == "tool":
+            if "tool_call_id" not in msg or not msg["tool_call_id"]:
+                continue
+                
+            if "name" not in msg or not msg["name"]:
+                # 如果能找到对应的工具调用，自动填充name
+                if msg["tool_call_id"] in tool_call_ids:
+                    msg["name"] = tool_call_ids[msg["tool_call_id"]]
+                else:
+                    continue
+        
+        fixed_messages.append(msg)
+    
+    return fixed_messages
+
+async def async_generator_to_json_stream(generator: AsyncGenerator) -> AsyncGenerator:
+    """将异步生成器转换为JSON流
+    
+    Args:
+        generator: 异步生成器
+        
+    Yields:
+        bytes: JSON流
+    """
+    async for item in generator:
+        yield json.dumps(item, ensure_ascii=False).encode('utf-8') + b'\n'