Update app.py

app.py

@@ -20,10 +20,10 @@ class KnowledgeGraph:
     relations: List[Relation] = field(default_factory=list)
 
 class KnowledgeGraphManager:
+    # ... (Manager 的所有内部方法保持不变) ...
     def __init__(self):
         self.graph = KnowledgeGraph()
         print("Initialized a new, empty in-memory knowledge graph.")
-    # ... Manager 的所有内部方法保持不变 ...
     def create_entities(self, entities_data: List[Dict]) -> List[Entity]:
         new_entities = []
         for e_data in entities_data:
@@ -75,146 +75,132 @@ class KnowledgeGraphManager:
 
 kg_manager = KnowledgeGraphManager()
 
-# --- 2. API 工具函数定义 (带有完整的文档字符串) ---
-# 这是我们将要精确暴露的 9 个函数。
-# 它们的输入和输出类型都是 Gradio 原生支持的，因此不需要 lambda。
-def create_entities(entities: List[Dict]) -> str:
-    # ... (函数实现和文档字符串保持不变) ...
+# --- 2. API 工具函数定义 (修改了函数签名和文档) ---
+def create_entities(payload: Dict) -> str:
     """在知识图谱中创建多个新实体。
 
     Args:
-        entities (List[Dict]): 一个实体对象的列表。每个对象应包含 'name', 'entityType', 'observations' 键。
+        payload (Dict): 一个包含'entities'键的JSON对象。'entities'的值是一个实体对象的列表。
     
     Returns:
         str: 表示成功创建的新实体的JSON字符串。
     """
-    new_entities = kg_manager.create_entities(entities)
+    new_entities = kg_manager.create_entities(payload['entities'])
     return json.dumps([asdict(e) for e in new_entities], indent=2)
 
-def create_relations(relations: List[Dict]) -> str:
-    """在知识图谱中的实体之间创建多个新关系。关系应使用主动语态。
+def create_relations(payload: Dict) -> str:
+    """在知识图谱中的实体之间创建多个新关系。
 
     Args:
-        relations (List[Dict]): 一个关系对象的列表。每个对象应包含 'from', 'to', 'relationType' 键。
+        payload (Dict): 一个包含'relations'键的JSON对象。'relations'的值是一个关系对象的列表。
 
     Returns:
         str: 表示成功创建的新关系的JSON字符串。
     """
-    new_relations = kg_manager.create_relations(relations)
+    new_relations = kg_manager.create_relations(payload['relations'])
     return json.dumps([{"from": r.from_entity, "to": r.to_entity, "relationType": r.relationType} for r in new_relations], indent=2)
 
-def add_observations(observations: List[Dict]) -> str:
+def add_observations(payload: Dict) -> str:
     """向知识图谱中已存在的实体添加新的观察记录。
 
     Args:
-        observations (List[Dict]): 一个观察对象的列表。每个对象应包含 'entityName' 和 'contents' (字符串列表)。
+        payload (Dict): 一个包含'observations'键的JSON对象。'observations'的值是一个观察记录对象的列表。
 
     Returns:
         str: 表示成功添加的观察记录的JSON字符串。
     """
-    results = kg_manager.add_observations(observations)
+    results = kg_manager.add_observations(payload['observations'])
     return json.dumps(results, indent=2)
 
-def delete_entities(entityNames: List[str]) -> str:
+def delete_entities(payload: Dict) -> str:
     """从知识图谱中删除多个实体及其相关联的关系。
 
     Args:
-        entityNames (List[str]): 一个要删除的实体名称的列表。
+        payload (Dict): 一个包含'entityNames'键的JSON对象。'entityNames'的值是一个实体名称的列表。
 
     Returns:
         str: 表示操作成功的消息。
     """
-    kg_manager.delete_entities(entityNames)
+
+    kg_manager.delete_entities(payload['entityNames'])
     return "Entities and their relations deleted successfully."
 
-def delete_observations(deletions: List[Dict]) -> str:
+def delete_observations(payload: Dict) -> str:
     """从知识图谱中的实体删除特定的观察记录。
 
     Args:
-        deletions (List[Dict]): 一个删除指令的列表。每个对象应包含 'entityName' 和 'observations' (字符串列表)。
+        payload (Dict): 一个包含'deletions'键的JSON对象。'deletions'的值是一个删除指令的列表。
 
     Returns:
         str: 表示操作成功的消息。
     """
-    kg_manager.delete_observations(deletions)
+    kg_manager.delete_observations(payload['deletions'])
     return "Observations deleted successfully."
 
-def delete_relations(relations: List[Dict]) -> str:
+def delete_relations(payload: Dict) -> str:
     """从知识图谱中删除多个关系。
 
     Args:
-        relations (List[Dict]): 一个要删除的关系对象的列表。每个对象应包含 'from', 'to', 'relationType'。
+        payload (Dict): 一个包含'relations'键的JSON对象。'relations'的值是一个要删除的关系对象的列表。
 
     Returns:
         str: 表示操作成功的消息。
     """
-    kg_manager.delete_relations(relations)
+    kg_manager.delete_relations(payload['relations'])
     return "Relations deleted successfully."
 
 def read_graph() -> Dict:
-    """读取并返回整个知识图谱。
+    """读取并返回整个知识图谱。此函数不需要参数。
 
     Returns:
         Dict: 包含 'entities' 和 'relations' 列表的整个知识图谱。
     """
     return kg_manager.read_graph()
 
-def search_nodes(query: str) -> Dict:
+def search_nodes(payload: Dict) -> Dict:
     """根据查询词在知识图谱中搜索节点。
 
     Args:
-        query (str): 用于匹配实体名称、类型和观察内容的搜索词。
+        payload (Dict): 一个包含'query'键的JSON对象。'query'的值是用于搜索的字符串。
 
     Returns:
         Dict: 包含匹配的实体和它们之间关系的过滤后的知识图谱。
     """
-    return kg_manager.search_nodes(query)
+    return kg_manager.search_nodes(payload['query'])
 
-def open_nodes(names: List[str]) -> Dict:
+def open_nodes(payload: Dict) -> Dict:
     """通过名称打开知识图谱中的特定节点。
 
     Args:
-        names (List[str]): 一个要检索的实体名称的列表。
+        payload (Dict): 一个包含'names'键的JSON对象。'names'的值是一个要检索的实体名称的列表。
 
     Returns:
         Dict: 包含指定的实体和它们之间关系的过滤后的知识图谱。
     """
-    return kg_manager.open_nodes(names)
+    return kg_manager.open_nodes(payload['names'])
 
 # --- 3. Gradio Headless 应用构建与 API 注册 ---
 with gr.Blocks() as app:
-    # 我们不需要任何可见的UI组件，因为这个服务只给AI使用。
-    # 我们只需要一种方法来将我们的函数注册为API端点。
-    # 最干净的方法是使用 gr.load_api() 来定义API，但这需要更复杂的设置。
-    # 一个更简单、同样有效的方法是创建隐藏的组件来挂载API。
-    
     gr.Markdown("MCP Server is running. This UI is intentionally blank.", visible=True)
 
-    # 创建一组隐藏的组件，仅用于挂载我们的API函数
-    # 这些组件对用户不可见，但能让我们使用 .click() 和 api_name
     with gr.Row(visible=False):
-        # 定义一个触发器和一个存放状态的地方
+        # 定义一个统一的输入组件，因为所有函数现在都接收一个JSON对象
+        json_input = gr.JSON(value={})
+        # 定义一个统一的输出组件，因为输出总是JSON兼容的
+        generic_output = gr.JSON()
+        # 定义一个按钮作为所有API的挂载点
         dummy_btn = gr.Button()
-        # 定义不同类型的输入组件以匹配函数签名
-        dict_list_input = gr.JSON(value=[])
-        str_list_input = gr.CheckboxGroup(value=[])
-        str_input = gr.Textbox()
-        # 定义不同类型的输出组件
-        json_output = gr.JSON()
-        str_output = gr.Textbox()
-
-    # 将我们的 9 个函数绑定到这个隐藏的按钮上
-    # 这样它们就会被正确地注册为带有 api_name 的工具
-    # 并且因为它们没有使用 lambda，所以不会产生无用的工具
-    dummy_btn.click(fn=create_entities, inputs=dict_list_input, outputs=str_output, api_name="create_entities")
-    dummy_btn.click(fn=create_relations, inputs=dict_list_input, outputs=str_output, api_name="create_relations")
-    dummy_btn.click(fn=add_observations, inputs=dict_list_input, outputs=str_output, api_name="add_observations")
-    dummy_btn.click(fn=delete_entities, inputs=str_list_input, outputs=str_output, api_name="delete_entities")
-    dummy_btn.click(fn=delete_observations, inputs=dict_list_input, outputs=str_output, api_name="delete_observations")
-    dummy_btn.click(fn=delete_relations, inputs=dict_list_input, outputs=str_output, api_name="delete_relations")
-    dummy_btn.click(fn=read_graph, inputs=None, outputs=json_output, api_name="read_graph")
-    dummy_btn.click(fn=search_nodes, inputs=str_input, outputs=json_output, api_name="search_nodes")
-    dummy_btn.click(fn=open_nodes, inputs=str_list_input, outputs=json_output, api_name="open_nodes")
+
+    # 将我们的 9 个函数绑定到虚拟按钮上
+    dummy_btn.click(fn=create_entities, inputs=json_input, outputs=generic_output, api_name="create_entities")
+    dummy_btn.click(fn=create_relations, inputs=json_input, outputs=generic_output, api_name="create_relations")
+    dummy_btn.click(fn=add_observations, inputs=json_input, outputs=generic_output, api_name="add_observations")
+    dummy_btn.click(fn=delete_entities, inputs=json_input, outputs=generic_output, api_name="delete_entities")
+    dummy_btn.click(fn=delete_observations, inputs=json_input, outputs=generic_output, api_name="delete_observations")
+    dummy_btn.click(fn=delete_relations, inputs=json_input, outputs=generic_output, api_name="delete_relations")
+    dummy_btn.click(fn=read_graph, inputs=None, outputs=generic_output, api_name="read_graph")
+    dummy_btn.click(fn=search_nodes, inputs=json_input, outputs=generic_output, api_name="search_nodes")
+    dummy_btn.click(fn=open_nodes, inputs=json_input, outputs=generic_output, api_name="open_nodes")
 
 if __name__ == "__main__":
     app.launch(mcp_server=True)