Update Dockerfile

Dockerfile

@@ -28,15 +28,16 @@ RUN uv pip install -e .
 # 安装额外的web依赖
 RUN uv pip install fastapi uvicorn python-multipart
 
-# 创建一个HTTP API包装器
+# 创建一个探索性的HTTP API包装器
 COPY <<'EOF' /app/http_wrapper.py
 #!/usr/bin/env python3
 
 import asyncio
 import json
 import logging
+import traceback
 from contextlib import asynccontextmanager
-from typing import Any, Dict
+from typing import Any, Dict, Optional, List
 
 import uvicorn
 from fastapi import FastAPI, HTTPException
@@ -55,91 +56,130 @@ class SearchRequest(BaseModel):
 class DownloadRequest(BaseModel):
     paper_id: str
 
-# 全局变量存储工具
-tools = {}
+# 全局变量
+available_functions = {}
+project_info = {}
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """初始化MCP工具"""
-    global tools
+async def explore_project_structure():
+    """探索项目结构并找到可用的功能"""
+    global available_functions, project_info
+    
     try:
-        # 导入MCP服务器的工具
-        from paper_search_mcp.server import (
-            SearchArxivTool, 
-            SearchPubmedTool, 
-            SearchBiorxivTool,
-            DownloadArxivTool,
-            DownloadPubmedTool
-        )
+        # 尝试导入主模块
+        import paper_search_mcp
+        project_info['main_module'] = True
+        logger.info("主模块导入成功")
+        
+        # 尝试导入服务器模块
+        try:
+            import paper_search_mcp.server as server_module
+            project_info['server_module'] = dir(server_module)
+            logger.info(f"服务器模块属性: {project_info['server_module']}")
+        except Exception as e:
+            logger.error(f"服务器模块导入失败: {e}")
+        
+        # 尝试导入学术平台模块
+        try:
+            import paper_search_mcp.academic_platforms as platforms
+            project_info['platforms_module'] = dir(platforms)
+            logger.info(f"学术平台模块属性: {project_info['platforms_module']}")
+            
+            # 尝试获取具体的搜索函数
+            for attr_name in dir(platforms):
+                if not attr_name.startswith('_'):
+                    attr = getattr(platforms, attr_name)
+                    if callable(attr):
+                        available_functions[attr_name] = attr
+                        logger.info(f"找到可调用函数: {attr_name}")
+                        
+        except Exception as e:
+            logger.error(f"学术平台模块导入失败: {e}")
+            
+        # 尝试导入各个子模块
+        submodules = ['arxiv', 'pubmed', 'biorxiv', 'scihub']
+        for submodule in submodules:
+            try:
+                module = __import__(f'paper_search_mcp.academic_platforms.{submodule}', fromlist=[submodule])
+                project_info[f'{submodule}_module'] = dir(module)
+                logger.info(f"{submodule}模块属性: {project_info[f'{submodule}_module']}")
+                
+                # 查找搜索函数
+                for attr_name in dir(module):
+                    if not attr_name.startswith('_') and 'search' in attr_name.lower():
+                        attr = getattr(module, attr_name)
+                        if callable(attr):
+                            available_functions[f'{submodule}_{attr_name}'] = attr
+                            logger.info(f"找到{submodule}搜索函数: {attr_name}")
+                            
+            except Exception as e:
+                logger.warning(f"子模块 {submodule} 导入失败: {e}")
         
-        # 初始化工具
-        tools = {
-            'search_arxiv': SearchArxivTool(),
-            'search_pubmed': SearchPubmedTool(),
-            'search_biorxiv': SearchBiorxivTool(),
-            'download_arxiv': DownloadArxivTool(),
-            'download_pubmed': DownloadPubmedTool(),
-        }
+        logger.info(f"总共找到 {len(available_functions)} 个可用函数")
         
-        logger.info("MCP工具初始化完成")
-        yield
     except Exception as e:
-        logger.error(f"初始化失败: {e}")
-        yield
+        logger.error(f"项目探索失败: {e}")
+        logger.error(traceback.format_exc())
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """应用生命周期管理"""
+    await explore_project_structure()
+    yield
 
 # 创建FastAPI应用
 app = FastAPI(
     title="Paper Search MCP Server",
-    description="HTTP wrapper for Paper Search MCP Server",
+    description="HTTP wrapper for Paper Search MCP Server with dynamic function discovery",
     version="1.0.0",
     lifespan=lifespan
 )
 
 @app.get("/", response_class=HTMLResponse)
 async def root():
-    return """
+    return f"""
     <!DOCTYPE html>
     <html>
     <head>
         <title>Paper Search MCP Server</title>
         <style>
-            body { font-family: Arial, sans-serif; margin: 40px; }
-            .endpoint { background: #f5f5f5; padding: 10px; margin: 10px 0; border-radius: 5px; }
-            .method { color: #0066cc; font-weight: bold; }
+            body {{ font-family: Arial, sans-serif; margin: 40px; }}
+            .info {{ background: #e7f3ff; padding: 15px; margin: 15px 0; border-radius: 5px; }}
+            .endpoint {{ background: #f5f5f5; padding: 10px; margin: 10px 0; border-radius: 5px; }}
+            .method {{ color: #0066cc; font-weight: bold; }}
+            pre {{ background: #f8f8f8; padding: 10px; border-radius: 3px; overflow-x: auto; }}
         </style>
     </head>
     <body>
         <h1>Paper Search MCP Server</h1>
-        <p>HTTP wrapper for the Paper Search MCP Server</p>
+        <p>HTTP wrapper with dynamic function discovery</p>
         
-        <h2>Available Endpoints:</h2>
-        
-        <div class="endpoint">
-            <span class="method">GET</span> <code>/health</code> - Health check
+        <div class="info">
+            <h3>发现的功能 ({len(available_functions)} 个):</h3>
+            <pre>{json.dumps(list(available_functions.keys()), indent=2)}</pre>
         </div>
         
-        <div class="endpoint">
-            <span class="method">POST</span> <code>/search/arxiv</code> - Search ArXiv papers
-            <br><small>Body: {"query": "machine learning", "max_results": 10}</small>
+        <div class="info">
+            <h3>项目信息:</h3>
+            <pre>{json.dumps(project_info, indent=2, default=str)}</pre>
         </div>
         
+        <h2>可用端点:</h2>
+        
         <div class="endpoint">
-            <span class="method">POST</span> <code>/search/pubmed</code> - Search PubMed papers
-            <br><small>Body: {"query": "covid-19", "max_results": 10}</small>
+            <span class="method">GET</span> <code>/health</code> - 健康检查
         </div>
         
         <div class="endpoint">
-            <span class="method">POST</span> <code>/search/biorxiv</code> - Search bioRxiv papers
-            <br><small>Body: {"query": "genomics", "max_results": 10}</small>
+            <span class="method">GET</span> <code>/functions</code> - 列出所有发现的功能
         </div>
         
         <div class="endpoint">
-            <span class="method">POST</span> <code>/download/arxiv</code> - Download ArXiv paper
-            <br><small>Body: {"paper_id": "2301.12345"}</small>
+            <span class="method">POST</span> <code>/search</code> - 通用搜索接口
+            <br><small>Body: {{"platform": "arxiv", "query": "machine learning", "max_results": 10}}</small>
         </div>
         
         <div class="endpoint">
-            <span class="method">GET</span> <code>/docs</code> - API documentation (Swagger)
+            <span class="method">GET</span> <code>/docs</code> - API文档 (Swagger)
         </div>
     </body>
     </html>
@@ -147,63 +187,101 @@ async def root():
 
 @app.get("/health")
 async def health():
-    return {"status": "healthy", "tools_loaded": len(tools)}
+    return {
+        "status": "healthy", 
+        "functions_loaded": len(available_functions),
+        "available_functions": list(available_functions.keys())
+    }
 
-@app.post("/search/arxiv")
-async def search_arxiv(request: SearchRequest):
-    try:
-        if 'search_arxiv' not in tools:
-            raise HTTPException(status_code=500, detail="ArXiv search tool not available")
-        
-        # 调用MCP工具
-        tool = tools['search_arxiv']
-        result = await tool.search_papers(request.query, request.max_results)
-        
-        return {"results": result, "count": len(result)}
-    except Exception as e:
-        logger.error(f"ArXiv search error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+@app.get("/functions")
+async def list_functions():
+    return {
+        "available_functions": list(available_functions.keys()),
+        "project_info": project_info
+    }
 
-@app.post("/search/pubmed")
-async def search_pubmed(request: SearchRequest):
-    try:
-        if 'search_pubmed' not in tools:
-            raise HTTPException(status_code=500, detail="PubMed search tool not available")
-        
-        tool = tools['search_pubmed']
-        result = await tool.search_papers(request.query, request.max_results)
-        
-        return {"results": result, "count": len(result)}
-    except Exception as e:
-        logger.error(f"PubMed search error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+class GenericSearchRequest(BaseModel):
+    platform: str
+    query: str
+    max_results: int = 10
 
-@app.post("/search/biorxiv")
-async def search_biorxiv(request: SearchRequest):
+@app.post("/search")
+async def generic_search(request: GenericSearchRequest):
     try:
-        if 'search_biorxiv' not in tools:
-            raise HTTPException(status_code=500, detail="bioRxiv search tool not available")
+        # 查找合适的搜索函数
+        possible_function_names = [
+            f"{request.platform}_search",
+            f"search_{request.platform}",
+            f"{request.platform}_search_papers",
+            request.platform
+        ]
         
-        tool = tools['search_biorxiv']
-        result = await tool.search_papers(request.query, request.max_results)
+        search_function = None
+        used_function_name = None
         
-        return {"results": result, "count": len(result)}
-    except Exception as e:
-        logger.error(f"bioRxiv search error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/download/arxiv")
-async def download_arxiv(request: DownloadRequest):
-    try:
-        if 'download_arxiv' not in tools:
-            raise HTTPException(status_code=500, detail="ArXiv download tool not available")
+        for func_name in possible_function_names:
+            if func_name in available_functions:
+                search_function = available_functions[func_name]
+                used_function_name = func_name
+                break
         
-        tool = tools['download_arxiv']
-        result = await tool.download_paper(request.paper_id)
+        if not search_function:
+            return {
+                "error": f"No search function found for platform: {request.platform}",
+                "available_functions": list(available_functions.keys()),
+                "searched_for": possible_function_names
+            }
         
-        return {"download_info": result}
+        # 尝试调用搜索函数
+        try:
+            # 尝试不同的参数组合
+            result = None
+            error_msgs = []
+            
+            # 尝试1: (query, max_results)
+            try:
+                result = await asyncio.to_thread(search_function, request.query, request.max_results)
+            except Exception as e1:
+                error_msgs.append(f"尝试1失败: {str(e1)}")
+                
+                # 尝试2: 只传query
+                try:
+                    result = await asyncio.to_thread(search_function, request.query)
+                except Exception as e2:
+                    error_msgs.append(f"尝试2失败: {str(e2)}")
+                    
+                    # 尝试3: 字典参数
+                    try:
+                        result = await asyncio.to_thread(search_function, {
+                            'query': request.query,
+                            'max_results': request.max_results
+                        })
+                    except Exception as e3:
+                        error_msgs.append(f"尝试3失败: {str(e3)}")
+            
+            if result is not None:
+                return {
+                    "platform": request.platform,
+                    "function_used": used_function_name,
+                    "results": result,
+                    "count": len(result) if isinstance(result, (list, tuple)) else 1
+                }
+            else:
+                return {
+                    "error": "所有调用尝试都失败了",
+                    "function_used": used_function_name,
+                    "error_messages": error_msgs
+                }
+                
+        except Exception as e:
+            logger.error(f"搜索函数调用错误: {e}")
+            return {
+                "error": f"Function call failed: {str(e)}",
+                "function_used": used_function_name
+            }
+            
     except Exception as e:
-        logger.error(f"ArXiv download error: {e}")
+        logger.error(f"通用搜索错误: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 if __name__ == "__main__":