Merge pull request #277 from Dear47/main

修改tool方法和参数错误

code/chapter8/01_MemoryTool_Basic_Operations.py

@@ -8,6 +8,8 @@
 from datetime import datetime
 from typing import List
 from hello_agents.tools import MemoryTool
+from dotenv import load_dotenv
+load_dotenv()
 
 def memory_tool_execute_demo():
     """MemoryTool execute方法演示"""
@@ -29,48 +31,48 @@ def add_memory_demo(memory_tool):
     """添加记忆演示 - 模拟人类记忆编码过程"""
     print("\n📝 添加记忆演示")
     print("-" * 30)
-    
+
     # 添加工作记忆
-    result = memory_tool.execute(
-        "add",
-        content="正在学习HelloAgents框架的记忆系统",
-        memory_type="working",
-        importance=0.7,
-        task_type="learning"
-    )
+    result = memory_tool.run({
+        "action":"add",
+        "content":"正在学习HelloAgents框架的记忆系统",
+        "memory_type":"working",
+        "importance":0.7,
+        "task_type":"learning"
+    })
     print(f"工作记忆: {result}")
     
     # 添加情景记忆
-    result = memory_tool.execute(
-        "add",
-        content="2024年开始深入研究AI Agent技术",
-        memory_type="episodic",
-        importance=0.8,
-        event_type="milestone",
-        location="研发中心"
-    )
+    result = memory_tool.run({
+        "action":"add",
+        "content":"2024年开始深入研究AI Agent技术",
+        "memory_type":"episodic",
+        "importance":0.8,
+        "event_type":"milestone",
+        "location":"研发中心"
+    })
     print(f"情景记忆: {result}")
     
     # 添加语义记忆
-    result = memory_tool.execute(
-        "add",
-        content="记忆系统包括工作记忆、情景记忆、语义记忆和感知记忆四种类型",
-        memory_type="semantic",
-        importance=0.9,
-        concept="memory_types",
-        domain="cognitive_science"
-    )
+    result = memory_tool.run({
+        "action":"add",
+        "content":"记忆系统包括工作记忆、情景记忆、语义记忆和感知记忆四种类型",
+        "memory_type":"semantic",
+        "importance":0.9,
+        "concept":"memory_types",
+        "domain":"cognitive_science"
+    })
     print(f"语义记忆: {result}")
     
     # 添加感知记忆
-    result = memory_tool.execute(
-        "add",
-        content="查看了记忆系统的架构图和实现代码",
-        memory_type="perceptual",
-        importance=0.6,
-        modality="document",
-        source="technical_documentation"
-    )
+    result = memory_tool.run({
+        "action":"add",
+        "content":"查看了记忆系统的架构图和实现代码",
+        "memory_type":"perceptual",
+        "importance":0.6,
+        "modality":"document",
+        "source":"technical_documentation"
+    })
     print(f"感知记忆: {result}")
 
 def search_memory_demo(memory_tool):
@@ -80,27 +82,27 @@ def search_memory_demo(memory_tool):
     
     # 基础搜索
     print("基础搜索 - '记忆系统':")
-    result = memory_tool.execute("search", query="记忆系统", limit=3)
+    result = memory_tool.run({"action":"search", "query":"记忆系统", "limit":3})
     print(result)
     
     # 按类型搜索
     print("\n按类型搜索 - 语义记忆中的'记忆':")
-    result = memory_tool.execute(
-        "search", 
-        query="记忆", 
-        memory_type="semantic", 
-        limit=2
-    )
+    result = memory_tool.run({
+        "action":"search", 
+        "query":"记忆", 
+        "memory_type":"semantic", 
+        "limit":2
+    })
     print(result)
     
     # 设置重要性阈值
     print("\n高重要性记忆搜索:")
-    result = memory_tool.execute(
-        "search", 
-        query="AI Agent", 
-        min_importance=0.7, 
-        limit=3
-    )
+    result = memory_tool.run({
+        "action":"search", 
+        "query":"AI Agent", 
+        "min_importance":0.7, 
+        "limit":3
+    })
     print(result)
 
 def memory_summary_demo(memory_tool):
@@ -109,13 +111,13 @@ def memory_summary_demo(memory_tool):
     print("-" * 30)
     
     # 获取记忆摘要
-    result = memory_tool.execute("summary", limit=5)
+    result = memory_tool.run({"action":"summary", "limit":5})
     print("记忆摘要:")
     print(result)
     
     # 获取统计信息
     print("\n📊 统计信息:")
-    result = memory_tool.execute("stats")
+    result = memory_tool.run({"action": "stats"})
     print(result)
 
 def memory_management_demo(memory_tool):
@@ -124,30 +126,30 @@ def memory_management_demo(memory_tool):
     print("-" * 30)
     
     # 添加一个低重要性记忆用于遗忘测试
-    memory_tool.execute(
-        "add",
-        content="这是一个临时的测试记忆，重要性很低",
-        memory_type="working",
-        importance=0.1
-    )
+    memory_tool.run({
+        "action":"add",
+        "content":"这是一个临时的测试记忆，重要性很低",
+        "memory_type":"working",
+        "importance":0.1
+    })
     
     # 基于重要性的遗忘
     print("基于重要性的遗忘 (阈值=0.2):")
-    result = memory_tool.execute(
-        "forget",
-        strategy="importance_based",
-        threshold=0.2
-    )
+    result = memory_tool.run({
+        "action":"forget",
+        "strategy":"importance_based",
+        "threshold":0.2
+    })
     print(result)
     
     # 记忆整合 - 将重要的工作记忆转为情景记忆
     print("\n记忆整合 (working → episodic):")
-    result = memory_tool.execute(
-        "consolidate",
-        from_type="working",
-        to_type="episodic",
-        importance_threshold=0.6
-    )
+    result = memory_tool.run({
+        "action":"consolidate",
+        "from_type":"working",
+        "to_type":"episodic",
+        "importance_threshold":0.6
+    })
     print(result)
 
 def main():

code/chapter8/02_MemoryTool_Architecture.py

@@ -9,6 +9,8 @@ from typing import List, Optional, Dict, Any
 from datetime import datetime
 from hello_agents.tools import MemoryTool
 from hello_agents.memory import MemoryConfig
+from dotenv import load_dotenv
+load_dotenv()
 
 class MemoryToolArchitectureDemo:
     """MemoryTool架构演示类"""
@@ -36,7 +38,7 @@ class MemoryToolArchitectureDemo:
         )
         
         print(f"\n✅ MemoryTool初始化完成")
-        print(f"👤 用户ID: {self.user_id}")
+        print(f"👤 用户ID: {memory_tool.memory_manager.user_id}")
         print(f"🧠 启用的记忆类型: {memory_tool.memory_types}")
         print(f"⚙️ 配置对象: {type(memory_tool.memory_config).__name__}")
         
@@ -105,36 +107,40 @@ class MemoryToolArchitectureDemo:
             
             # 添加示例记忆来演示特点
             if memory_type == "working":
-                memory_tool.execute("add",
-                    content=f"演示{info['name']}的临时存储特性",
-                    memory_type=memory_type,
-                    importance=0.6,
-                    demo_feature="temporary_storage"
-                )
+                memory_tool.run({
+                    "action":"add",
+                    "content":f"演示{info['name']}的临时存储特性",
+                    "memory_type":memory_type,
+                    "importance":0.6,
+                    "demo_feature":"temporary_storage"
+                })
             elif memory_type == "episodic":
-                memory_tool.execute("add",
-                    content=f"演示{info['name']}的事件记录特性",
-                    memory_type=memory_type,
-                    importance=0.7,
-                    event_type="demonstration",
-                    session_context="architecture_demo"
-                )
+                memory_tool.run({
+                    "action":"add",
+                    "content":f"演示{info['name']}的事件记录特性",
+                    "memory_type":memory_type,
+                    "importance":0.7,
+                    "event_type":"demonstration",
+                    "session_context":"architecture_demo"
+                })
             elif memory_type == "semantic":
-                memory_tool.execute("add",
-                    content=f"{info['name']}用于存储概念性知识和实体关系",
-                    memory_type=memory_type,
-                    importance=0.8,
-                    concept="memory_architecture",
-                    domain="cognitive_computing"
-                )
+                memory_tool.run({
+                    "action":"add",
+                    "content":f"{info['name']}用于存储概念性知识和实体关系",
+                    "memory_type":memory_type,
+                    "importance":0.8,
+                    "concept":"memory_architecture",
+                    "domain":"cognitive_computing"
+                })
             elif memory_type == "perceptual":
-                memory_tool.execute("add",
-                    content=f"演示{info['name']}的多模态数据处理",
-                    memory_type=memory_type,
-                    importance=0.6,
-                    modality="text",
-                    data_type="demonstration"
-                )
+                memory_tool.run({
+                    "action":"add",
+                    "content":f"演示{info['name']}的多模态数据处理",
+                    "memory_type":memory_type,
+                    "importance":0.6,
+                    "modality":"text",
+                    "data_type":"demonstration"
+                })
     
     def demonstrate_unified_interface(self, memory_tool):
         """演示统一接口的设计优势"""
@@ -158,7 +164,7 @@ class MemoryToolArchitectureDemo:
         for operation, params in operations:
             print(f"\n操作: {operation}")
             print(f"参数: {params}")
-            result = memory_tool.execute(operation, **params)
+            result = memory_tool.run({"action":operation, **params})
             print(f"结果: {result[:100]}..." if len(str(result)) > 100 else f"结果: {result}")
     
     def demonstrate_extensibility(self):
@@ -175,11 +181,11 @@ class MemoryToolArchitectureDemo:
         # 演示自定义配置
         custom_config = MemoryConfig()
         custom_config.working_memory_capacity = 100
-        custom_config.working_memory_ttl = 120
+        custom_config.working_memory_ttl_minutes = 120
         
         print(f"\n⚙️ 自定义配置示例:")
         print(f"工作记忆容量: {custom_config.working_memory_capacity}")
-        print(f"工作记忆TTL: {custom_config.working_memory_ttl}分钟")
+        print(f"工作记忆TTL: {custom_config.working_memory_ttl_minutes}分钟")
         
         # 演示选择性启用记忆类型
         selective_memory_tool = MemoryTool(

code/chapter8/03_WorkingMemory_Implementation.py

@@ -10,6 +10,8 @@ from datetime import datetime, timedelta
 from typing import List, Dict, Any
 from hello_agents.tools import MemoryTool
 from hello_agents.memory import MemoryItem
+from dotenv import load_dotenv
+load_dotenv()
 
 class WorkingMemoryDemo:
     """工作记忆演示类"""
@@ -35,25 +37,27 @@ class WorkingMemoryDemo:
         print(f"\n📝 添加测试记忆...")
         for i in range(10):
             importance = 0.3 + (i * 0.07)  # 递增重要性
-            self.memory_tool.execute("add",
-                content=f"工作记忆测试项目 {i+1} - 重要性 {importance:.2f}",
-                memory_type="working",
-                importance=importance,
-                test_id=i+1,
-                category="capacity_test"
-            )
+            self.memory_tool.run({
+                "action":"add",
+                "content":f"工作记忆测试项目 {i+1} - 重要性 {importance:.2f}",
+                "memory_type":"working",
+                "importance":importance,
+                "test_id":i+1,
+                "category":"capacity_test"
+            })
         
         # 查看当前状态
-        stats = self.memory_tool.execute("stats")
+        stats = self.memory_tool.run({"action":"stats"})
         print(f"当前状态: {stats}")
         
         # 演示重要性排序
         print(f"\n🔍 按重要性搜索:")
-        result = self.memory_tool.execute("search", 
-            query="测试项目", 
-            memory_type="working",
-            limit=5
-        )
+        result = self.memory_tool.run({
+            "action":"search", 
+            "query":"测试项目", 
+            "memory_type":"working",
+            "limit":5
+        })
         print(result)
     
     def demonstrate_mixed_retrieval_strategy(self):
@@ -99,12 +103,13 @@ class WorkingMemoryDemo:
         for i, memory in enumerate(test_memories):
             content = memory.pop("content")
             importance = memory.pop("importance")
-            self.memory_tool.execute("add",
-                content=content,
-                memory_type="working",
-                importance=importance,
+            self.memory_tool.run({
+                "action":"add",
+                "content":content,
+                "memory_type":"working",
+                "importance":importance,
                 **memory
-            )
+            })
         
         # 测试不同类型的检索
         search_tests = [
@@ -117,11 +122,12 @@ class WorkingMemoryDemo:
         print(f"\n🔍 混合检索测试:")
         for query, description in search_tests:
             print(f"\n查询: '{query}' ({description})")
-            result = self.memory_tool.execute("search",
-                query=query,
-                memory_type="working",
-                limit=2
-            )
+            result = self.memory_tool.run({
+                "action":"search",
+                "query":query,
+                "memory_type":"working",
+                "limit":2
+            })
             print(f"结果: {result}")
     
     def demonstrate_time_decay_mechanism(self):
@@ -145,21 +151,23 @@ class WorkingMemoryDemo:
         
         print(f"\n📝 添加不同时期的记忆...")
         for content, importance, age_category in time_test_memories:
-            self.memory_tool.execute("add",
-                content=content,
-                memory_type="working",
-                importance=importance,
-                age_category=age_category,
-                timestamp_category=age_category
-            )
+            self.memory_tool.run({
+                "action":"add",
+                "content":content,
+                "memory_type":"working",
+                "importance":importance,
+                "age_category":age_category,
+                "timestamp_category":age_category
+            })
         
         # 搜索测试时间衰减效果
         print(f"\n🔍 时间衰减效果测试:")
-        result = self.memory_tool.execute("search",
-            query="学习的内容",
-            memory_type="working",
-            limit=4
-        )
+        result = self.memory_tool.run({
+            "action":"search",
+            "query":"学习的内容",
+            "memory_type":"working",
+            "limit":4
+        })
         print("搜索结果（注意时间因素对排序的影响）:")
         print(result)
     
@@ -175,30 +183,32 @@ class WorkingMemoryDemo:
         print("• 模拟工作记忆的有限容量")
         
         # 获取清理前的状态
-        stats_before = self.memory_tool.execute("stats")
+        stats_before = self.memory_tool.run({"action":"stats"})
         print(f"\n清理前状态: {stats_before}")
         
         # 添加一些低重要性的记忆
         print(f"\n📝 添加低重要性记忆...")
         for i in range(5):
-            self.memory_tool.execute("add",
-                content=f"低重要性临时记忆 {i+1}",
-                memory_type="working",
-                importance=0.1 + i * 0.05,
-                temporary=True,
-                cleanup_test=True
-            )
+            self.memory_tool.run({
+                "action":"add",
+                "content":f"低重要性临时记忆 {i+1}",
+                "memory_type":"working",
+                "importance":0.1 + i * 0.05,
+                "temporary":True,
+                "cleanup_test":True
+            })
         
         # 触发基于重要性的清理
         print(f"\n🧹 执行基于重要性的清理...")
-        cleanup_result = self.memory_tool.execute("forget",
-            strategy="importance_based",
-            threshold=0.3
-        )
+        cleanup_result = self.memory_tool.run({
+            "action":"forget",
+            "strategy":"importance_based",
+            "threshold":0.3
+        })
         print(f"清理结果: {cleanup_result}")
         
         # 获取清理后的状态
-        stats_after = self.memory_tool.execute("stats")
+        stats_after = self.memory_tool.run({"action":"stats"})
         print(f"\n清理后状态: {stats_after}")
     
     def demonstrate_performance_characteristics(self):
@@ -218,28 +228,30 @@ class WorkingMemoryDemo:
         # 批量添加测试
         start_time = time.time()
         for i in range(20):
-            self.memory_tool.execute("add",
-                content=f"性能测试记忆 {i+1}",
-                memory_type="working",
-                importance=0.5,
-                performance_test=True
-            )
+            self.memory_tool.run({
+                "action":"add",
+                "content":f"性能测试记忆 {i+1}",
+                "memory_type":"working",
+                "importance":0.5,
+                "performance_test":True
+            })
         add_time = time.time() - start_time
         print(f"批量添加20条记忆耗时: {add_time:.3f}秒")
         
         # 批量搜索测试
         start_time = time.time()
         for i in range(10):
-            self.memory_tool.execute("search",
-                query=f"性能测试",
-                memory_type="working",
-                limit=3
-            )
+            self.memory_tool.run({
+                "action":"search",
+                "query":f"性能测试",
+                "memory_type":"working",
+                "limit":3
+            })
         search_time = time.time() - start_time
         print(f"批量搜索10次耗时: {search_time:.3f}秒")
         
         # 获取最终统计
-        final_stats = self.memory_tool.execute("stats")
+        final_stats = self.memory_tool.run("stats")
         print(f"\n📊 最终统计: {final_stats}")
 
 def main():

code/chapter8/04_RAGTool_MarkItDown_Pipeline.py

@@ -9,6 +9,8 @@ import os
 import time
 import tempfile
 from hello_agents.tools import RAGTool
+from dotenv import load_dotenv
+load_dotenv()
 
 class MarkItDownPipelineDemo:
     """MarkItDown处理管道演示类"""
@@ -153,8 +155,8 @@ class Person:
             start_time = time.time()
             
             # 使用RAGTool添加文档，内部会调用MarkItDown
-            result = self.rag_tool.execute("add_document", 
-                                         file_path=file_path)
+            result = self.rag_tool.run({"action":"add_document", 
+                                         "file_path":file_path})
             
             process_time = time.time() - start_time
             
@@ -245,11 +247,11 @@ class Person:
 """
         
         print(f"\n📝 添加复杂Markdown文档进行分块测试...")
-        result = self.rag_tool.execute("add_text",
-                                     text=complex_markdown,
-                                     document_id="ai_tech_stack",
-                                     chunk_size=800,
-                                     chunk_overlap=100)
+        result = self.rag_tool.run({"action":"add_text",
+                                     "text":complex_markdown,
+                                     "document_id":"ai_tech_stack",
+                                     "chunk_size":800,
+                                     "chunk_overlap":100})
         
         print(f"分块结果: {result}")
         
@@ -265,9 +267,9 @@ class Person:
         
         for query, description in search_queries:
             print(f"\n查询: '{query}' ({description})")
-            search_result = self.rag_tool.execute("search",
-                                                query=query,
-                                                limit=2)
+            search_result = self.rag_tool.run({"action":"search",
+                                                "query":query,
+                                                "limit":2})
             print(f"检索结果: {search_result[:200]}...")
     
     def demonstrate_embedding_optimization(self):
@@ -301,17 +303,17 @@ def process_data(data):
         print(raw_markdown)
         
         # 添加到RAG系统，内部会进行预处理
-        result = self.rag_tool.execute("add_text",
-                                     text=raw_markdown,
-                                     document_id="preprocessing_demo")
+        result = self.rag_tool.run({"action":"add_text",
+                                     "text":raw_markdown,
+                                     "document_id":"preprocessing_demo"})
         
         print(f"\n✅ 预处理并添加完成: {result}")
         
         # 测试预处理后的检索效果
         print(f"\n🔍 测试预处理后的检索效果:")
-        search_result = self.rag_tool.execute("search",
-                                            query="Python函数处理数据",
-                                            limit=1)
+        search_result = self.rag_tool.run({"action":"search",
+                                            "query":"Python函数处理数据",
+                                            "limit":1})
         print(f"检索结果: {search_result}")
     
     def demonstrate_pipeline_performance(self):
@@ -348,7 +350,7 @@ def process_data(data):
         print(f"平均每文档: {batch_time/10:.3f}秒")
         
         # 获取最终统计
-        stats = self.rag_tool.execute("stats")
+        stats = self.rag_tool.run({"action":"stats"})
         print(f"\n📊 最终统计: {stats}")
 
 def main():

code/chapter8/05_RAGTool_Advanced_Search.py

@@ -7,6 +7,8 @@
 
 import time
 from hello_agents.tools import RAGTool
+from dotenv import load_dotenv
+load_dotenv()
 
 class AdvancedSearchDemo:
     """高级检索演示类"""
@@ -163,9 +165,9 @@ Transformer的核心是自注意力机制（Self-Attention），它允许模型
         
         # 批量添加文档
         for doc in tech_documents:
-            result = self.rag_tool.execute("add_text",
-                                         text=doc["content"],
-                                         document_id=doc["id"])
+            result = self.rag_tool.run({"action":"add_text",
+                                         "text":doc["content"],
+                                         "document_id":doc["id"]})
             print(f"✅ 添加文档: {doc['id']}")
         
         print(f"📊 知识库设置完成，共添加 {len(tech_documents)} 个文档")
@@ -193,10 +195,10 @@ Transformer的核心是自注意力机制（Self-Attention），它允许模型
             print(f"\n查询: '{query}' ({description})")
             
             start_time = time.time()
-            result = self.rag_tool.execute("search",
-                                         query=query,
-                                         limit=2,
-                                         enable_advanced_search=False)
+            result = self.rag_tool.run({"action":"search",
+                                         "query":query,
+                                         "limit":2,
+                                         "enable_advanced_search":False})
             search_time = time.time() - start_time
             
             print(f"耗时: {search_time:.3f}秒")
@@ -225,18 +227,18 @@ Transformer的核心是自注意力机制（Self-Attention），它允许模型
             
             # 基础搜索对比
             start_time = time.time()
-            basic_result = self.rag_tool.execute("search",
-                                               query=query,
-                                               limit=3,
-                                               enable_advanced_search=False)
+            basic_result = self.rag_tool.run({"action":"search",
+                                               "query":query,
+                                               "limit":3,
+                                               "enable_advanced_search":False})
             basic_time = time.time() - start_time
             
             # MQE搜索
             start_time = time.time()
-            mqe_result = self.rag_tool.execute("search",
-                                             query=query,
-                                             limit=3,
-                                             enable_advanced_search=True)
+            mqe_result = self.rag_tool.run({"action":"search",
+                                             "query":query,
+                                             "limit":3,
+                                             "enable_advanced_search":True})
             mqe_time = time.time() - start_time
             
             print(f"基础搜索耗时: {basic_time:.3f}秒")
@@ -268,10 +270,10 @@ Transformer的核心是自注意力机制（Self-Attention），它允许模型
             
             # 使用智能问答（内部使用HyDE）
             start_time = time.time()
-            hyde_result = self.rag_tool.execute("ask",
-                                              question=query,
-                                              limit=3,
-                                              enable_advanced_search=True)
+            hyde_result = self.rag_tool.run({"action":"ask",
+                                              "question":query,
+                                              "limit":3,
+                                              "enable_advanced_search":True})
             hyde_time = time.time() - start_time
             
             print(f"HyDE问答耗时: {hyde_time:.3f}秒")
@@ -302,17 +304,17 @@ Transformer的核心是自注意力机制（Self-Attention），它允许模型
             start_time = time.time()
             
             # 先进行高级搜索获取相关片段
-            search_result = self.rag_tool.execute("search",
-                                                query=query,
-                                                limit=4,
-                                                enable_advanced_search=True)
+            search_result = self.rag_tool.run({"action":"search",
+                                                "query":query,
+                                                "limit":4,
+                                                "enable_advanced_search":True})
             
             # 再进行智能问答生成完整答案
-            qa_result = self.rag_tool.execute("ask",
-                                            question=query,
-                                            limit=4,
-                                            enable_advanced_search=True,
-                                            include_citations=True)
+            qa_result = self.rag_tool.run({"action":"ask",
+                                            "question":query,
+                                            "limit":4,
+                                            "enable_advanced_search":True,
+                                            "include_citations":True})
             
             combined_time = time.time() - start_time
             
@@ -356,10 +358,10 @@ Transformer的核心是自注意力机制（Self-Attention），它允许模型
             for query in performance_queries:
                 start_time = time.time()
                 
-                result = self.rag_tool.execute("search",
-                                             query=query,
-                                             limit=3,
-                                             **params)
+                result = self.rag_tool.run({"action":"search",
+                                             "query":query,
+                                             "limit":3,
+                                             **params})
                 
                 query_time = time.time() - start_time
                 strategy_times.append(query_time)
@@ -385,7 +387,7 @@ Transformer的核心是自注意力机制（Self-Attention），它允许模型
         print(f"分析: 高级搜索通过多策略提升检索质量，耗时增加 {((advanced_avg/basic_avg-1)*100):.0f}%")
         
         # 获取系统统计
-        stats = self.rag_tool.execute("stats")
+        stats = self.rag_tool.run({"action":"stats"})
         print(f"\n📊 系统统计: {stats}")
 
 def main():

code/chapter8/06_Memory_Consolidation_Demo.py

@@ -8,6 +8,8 @@
 import time
 from datetime import datetime, timedelta
 from hello_agents.tools import MemoryTool
+from dotenv import load_dotenv
+load_dotenv()
 
 class MemoryConsolidationDemo:
     """记忆整合演示类"""
@@ -80,18 +82,18 @@ class MemoryConsolidationDemo:
             content = memory.pop("content")
             importance = memory.pop("importance")
             
-            result = self.memory_tool.execute("add",
-                                            content=content,
-                                            memory_type="working",
-                                            importance=importance,
-                                            **memory)
+            result = self.memory_tool.run({"action":"add",
+                                            "content":content,
+                                            "memory_type":"working",
+                                            "importance":importance,
+                                            **memory})
             
             print(f"  {i+1}. {content[:40]}... (重要性: {importance})")
         
         print(f"\n✅ 已添加 {len(working_memories)} 条工作记忆")
         
         # 显示当前状态
-        stats = self.memory_tool.execute("stats")
+        stats = self.memory_tool.run({"action":"stats"})
         print(f"\n📊 当前记忆统计:\n{stats}")
     
     def demonstrate_consolidation_criteria(self):
@@ -107,7 +109,7 @@ class MemoryConsolidationDemo:
         
         # 获取当前工作记忆摘要
         print("\n📋 整合前的工作记忆状态:")
-        summary = self.memory_tool.execute("summary", limit=10)
+        summary = self.memory_tool.run({"action":"summary", "limit":10})
         print(summary)
         
         # 测试不同阈值的整合效果
@@ -147,30 +149,30 @@ class MemoryConsolidationDemo:
             print(f"\n🔄 {description} (阈值: {threshold}):")
             
             # 获取整合前状态
-            stats_before = self.memory_tool.execute("stats")
+            stats_before = self.memory_tool.run({"action":"stats"})
             print(f"整合前状态: {stats_before}")
             
             # 执行整合
             start_time = time.time()
-            consolidation_result = self.memory_tool.execute("consolidate",
-                                                          from_type="working",
-                                                          to_type="episodic",
-                                                          importance_threshold=threshold)
+            consolidation_result = self.memory_tool.run({"action":"consolidate",
+                                                          "from_type":"working",
+                                                          "to_type":"episodic",
+                                                          "importance_threshold":threshold})
             consolidation_time = time.time() - start_time
             
             print(f"整合结果: {consolidation_result}")
             print(f"整合耗时: {consolidation_time:.3f}秒")
             
             # 获取整合后状态
-            stats_after = self.memory_tool.execute("stats")
+            stats_after = self.memory_tool.run({"action":"stats"})
             print(f"整合后状态: {stats_after}")
             
             # 查看整合后的情景记忆
             print(f"\n📚 整合后的情景记忆:")
-            episodic_search = self.memory_tool.execute("search",
-                                                     query="",
-                                                     memory_type="episodic",
-                                                     limit=5)
+            episodic_search = self.memory_tool.run({"action":"search",
+                                                     "query":"",
+                                                     "memory_type":"episodic",
+                                                     "limit":5})
             print(episodic_search)
     
     def demonstrate_consolidation_metadata(self):
@@ -185,32 +187,32 @@ class MemoryConsolidationDemo:
         print("• 保存原始ID引用")
         
         # 添加一个特殊的工作记忆用于演示
-        special_memory_result = self.memory_tool.execute("add",
-            content="这是一个用于演示整合元数据处理的特殊记忆",
-            memory_type="working",
-            importance=0.85,
-            special_tag="metadata_demo",
-            original_context="demonstration",
-            creation_purpose="show_consolidation_metadata"
-        )
+        special_memory_result = self.memory_tool.run({"action":"add",
+            "content":"这是一个用于演示整合元数据处理的特殊记忆",
+            "memory_type":"working",
+            "importance":0.85,
+            "special_tag":"metadata_demo",
+            "original_context":"demonstration",
+            "creation_purpose":"show_consolidation_metadata"
+        })
         
         print(f"添加特殊记忆: {special_memory_result}")
         
         # 执行整合
         print(f"\n🔄 执行整合...")
-        consolidation_result = self.memory_tool.execute("consolidate",
-                                                       from_type="working",
-                                                       to_type="episodic",
-                                                       importance_threshold=0.8)
+        consolidation_result = self.memory_tool.run({"action":"consolidate",
+                                                       "from_type":"working",
+                                                       "to_type":"episodic",
+                                                       "importance_threshold":0.8})
         
         print(f"整合结果: {consolidation_result}")
         
         # 搜索整合后的记忆查看元数据
         print(f"\n🔍 查看整合后的记忆元数据:")
-        search_result = self.memory_tool.execute("search",
-                                                query="特殊记忆",
-                                                memory_type="episodic",
-                                                limit=1)
+        search_result = self.memory_tool.run({"action":"search",
+                                                "query":"特殊记忆",
+                                                "memory_type":"episodic",
+                                                "limit":1})
         print(search_result)
     
     def demonstrate_multi_type_consolidation(self):
@@ -255,11 +257,11 @@ class MemoryConsolidationDemo:
             importance = memory.pop("importance")
             suitable_for = memory.pop("suitable_for")
             
-            result = self.memory_tool.execute("add",
-                                            content=content,
-                                            memory_type=memory_type,
-                                            importance=importance,
-                                            **memory)
+            result = self.memory_tool.run({"action":"add",
+                                            "content":content,
+                                            "memory_type":memory_type,
+                                            "importance":importance,
+                                            **memory})
             
             print(f"  • {content[:50]}... → 适合整合为{suitable_for}")
         
@@ -273,10 +275,10 @@ class MemoryConsolidationDemo:
         for from_type, to_type, threshold, description in consolidation_paths:
             print(f"\n🔄 {description} ({from_type} → {to_type}):")
             
-            result = self.memory_tool.execute("consolidate",
-                                            from_type=from_type,
-                                            to_type=to_type,
-                                            importance_threshold=threshold)
+            result = self.memory_tool.run({"action":"consolidate",
+                                            "from_type":from_type,
+                                            "to_type":to_type,
+                                            "importance_threshold":threshold})
             
             print(f"整合结果: {result}")
     
@@ -293,7 +295,7 @@ class MemoryConsolidationDemo:
         
         # 获取最终的记忆系统状态
         print(f"\n📊 最终记忆系统状态:")
-        final_stats = self.memory_tool.execute("stats")
+        final_stats = self.memory_tool.run({"action":"stats"})
         print(final_stats)
         
         # 获取各类型记忆的摘要
@@ -302,10 +304,10 @@ class MemoryConsolidationDemo:
         memory_types = ["working", "episodic", "semantic"]
         for memory_type in memory_types:
             print(f"\n{memory_type.upper()}记忆:")
-            type_summary = self.memory_tool.execute("search",
-                                                   query="",
-                                                   memory_type=memory_type,
-                                                   limit=3)
+            type_summary = self.memory_tool.run({"action":"search",
+                                                   "query":"",
+                                                   "memory_type":memory_type,
+                                                   "limit":3})
             print(type_summary)
         
         # 演示整合后的检索效果
@@ -318,9 +320,9 @@ class MemoryConsolidationDemo:
         
         for query, description in search_queries:
             print(f"\n查询: '{query}' ({description})")
-            result = self.memory_tool.execute("search",
-                                            query=query,
-                                            limit=3)
+            result = self.memory_tool.run({"action":"search",
+                                            "query":query,
+                                            "limit":3})
             print(result)
 
 def main():

code/chapter8/07_RAGTool_Intelligent_QA.py

@@ -7,6 +7,8 @@
 
 import time
 from hello_agents.tools import RAGTool
+from dotenv import load_dotenv
+load_dotenv()
 
 class IntelligentQADemo:
     """智能问答演示类"""
@@ -172,9 +174,9 @@ class IntelligentQADemo:
         
         # 批量添加知识文档
         for doc in knowledge_documents:
-            result = self.rag_tool.execute("add_text",
-                                         text=doc["content"],
-                                         document_id=doc["id"])
+            result = self.rag_tool.run({"action":"add_text",
+                                         "text":doc["content"],
+                                         "document_id":doc["id"]})
             print(f"✅ 添加知识文档: {doc['id']}")
         
         print(f"📊 知识库设置完成")
@@ -237,10 +239,10 @@ class IntelligentQADemo:
                 print(f"\n❓ 问题: {question}")
                 
                 start_time = time.time()
-                answer = self.rag_tool.execute("ask",
-                                             question=question,
-                                             limit=3,
-                                             include_citations=True)
+                answer = self.rag_tool.run({"action":"ask",
+                                             "question":question,
+                                             "limit":3,
+                                             "include_citations":True})
                 qa_time = time.time() - start_time
                 
                 print(f"⏱️ 响应时间: {qa_time:.3f}秒")
@@ -267,21 +269,21 @@ class IntelligentQADemo:
         
         # 先进行搜索，查看检索到的片段
         print(f"\n🔍 第一步：检索相关片段")
-        search_result = self.rag_tool.execute("search",
-                                            query=complex_question,
-                                            limit=4,
-                                            enable_advanced_search=True)
+        search_result = self.rag_tool.run({"action":"search",
+                                            "query":complex_question,
+                                            "limit":4,
+                                            "enable_advanced_search":True})
         print(f"检索片段: {search_result}")
         
         # 然后进行智能问答，查看完整的上下文构建
         print(f"\n🤖 第二步：构建上下文并生成答案")
         start_time = time.time()
-        qa_result = self.rag_tool.execute("ask",
-                                        question=complex_question,
-                                        limit=4,
-                                        enable_advanced_search=True,
-                                        include_citations=True,
-                                        max_chars=1500)
+        qa_result = self.rag_tool.run({"action":"ask",
+                                        "question":complex_question,
+                                        "limit":4,
+                                        "enable_advanced_search":True,
+                                        "include_citations":True,
+                                        "max_chars":1500})
         qa_time = time.time() - start_time
         
         print(f"问答耗时: {qa_time:.3f}秒")
@@ -332,11 +334,11 @@ class IntelligentQADemo:
             
             # 执行问答
             start_time = time.time()
-            answer = self.rag_tool.execute("ask",
-                                         question=question,
-                                         limit=4,
-                                         enable_advanced_search=True,
-                                         include_citations=True)
+            answer = self.rag_tool.run({"action":"ask",
+                                         "question":question,
+                                         "limit":4,
+                                         "enable_advanced_search":True,
+                                         "include_citations":True})
             qa_time = time.time() - start_time
             
             # 分析答案质量
@@ -465,9 +467,9 @@ class IntelligentQADemo:
             
             # 这里简化演示，实际的提示词工程在RAGTool内部实现
             start_time = time.time()
-            answer = self.rag_tool.execute("ask",
-                                         question=test_question,
-                                         limit=3)
+            answer = self.rag_tool.run({"action":"ask",
+                                         "question":test_question,
+                                         "limit":3})
             response_time = time.time() - start_time
             
             print(f"⏱️ 响应时间: {response_time:.3f}秒")
@@ -497,16 +499,16 @@ class IntelligentQADemo:
             print(f"\n❓ 问题: {question}")
             
             # 启用引用的问答
-            answer_with_citations = self.rag_tool.execute("ask",
-                                                        question=question,
-                                                        limit=3,
-                                                        include_citations=True)
+            answer_with_citations = self.rag_tool.run({"action":"ask",
+                                                        "question":question,
+                                                        "limit":3,
+                                                        "include_citations":True})
             
             # 禁用引用的问答对比
-            answer_without_citations = self.rag_tool.execute("ask",
-                                                           question=question,
-                                                           limit=3,
-                                                           include_citations=False)
+            answer_without_citations = self.rag_tool.run({"action":"ask",
+                                                           "question":question,
+                                                           "limit":3,
+                                                           "include_citations":False})
             
             print(f"🔗 带引用回答: {answer_with_citations[:400]}...")
             print(f"📝 无引用回答: {answer_without_citations[:200]}...")

code/chapter8/08_Agent_Tool_Integration.py

@@ -8,6 +8,8 @@
 import time
 from hello_agents import SimpleAgent, HelloAgentsLLM, ToolRegistry
 from hello_agents.tools import MemoryTool, RAGTool
+from dotenv import load_dotenv
+load_dotenv()
 
 class AgentIntegrationDemo:
     """Agent工具集成演示类"""
@@ -40,7 +42,7 @@ class AgentIntegrationDemo:
         self.agent = SimpleAgent(
             name="智能学习助手",
             llm=self.llm,
-            description="集成记忆和RAG功能的智能助手"
+            system_prompt="集成记忆和RAG功能的智能助手"
         )
         
         print("✅ Agent创建完成")
@@ -57,8 +59,8 @@ class AgentIntegrationDemo:
         # 显示Agent状态
         print(f"\n📊 Agent状态:")
         print(f"  名称: {self.agent.name}")
-        print(f"  描述: {self.agent.description}")
-        print(f"  可用工具: {list(self.tool_registry.tools.keys())}")
+        print(f"  描述: {self.agent.system_prompt}")
+        print(f"  可用工具: {list(self.tool_registry._tools.keys())}")
     
     def demonstrate_tool_registry_pattern(self):
         """演示工具注册模式"""
@@ -74,7 +76,7 @@ class AgentIntegrationDemo:
         # 演示工具注册过程
         print(f"\n🔧 工具注册详情:")
         
-        for tool_name, tool_instance in self.tool_registry.tools.items():
+        for tool_name, tool_instance in self.tool_registry._tools.items():
             print(f"\n工具: {tool_name}")
             print(f"  类型: {type(tool_instance).__name__}")
             print(f"  描述: {tool_instance.description}")
@@ -111,8 +113,8 @@ class AgentIntegrationDemo:
         print("• 🛡️ 统一的错误处理")
         print("• 🔄 简化的工具切换")
         
-        # 演示统一的execute接口
-        print(f"\n🔗 统一execute接口演示:")
+        # 演示统一的run接口
+        print(f"\n🔗 统一run接口演示:")
         
         # Memory工具操作
         print(f"\n1. Memory工具操作:")
@@ -131,17 +133,17 @@ class AgentIntegrationDemo:
         ]
         
         for operation, params in memory_operations:
-            print(f"  操作: memory.execute('{operation}', {params})")
-            result = self.memory_tool.execute(operation, **params)
+            print(f"  操作: memory.run('{operation}', {params})")
+            result = self.memory_tool.run({"action":operation, **params})
             print(f"  结果: {str(result)[:100]}...")
         
         # RAG工具操作
         print(f"\n2. RAG工具操作:")
         
         # 先添加一些内容
-        self.rag_tool.execute("add_text",
-                            text="Agent工具集成是HelloAgents框架的核心特性，允许Agent使用多种工具来完成复杂任务。",
-                            document_id="agent_integration_guide")
+        self.rag_tool.run({"action":"add_text",
+                            "text":"Agent工具集成是HelloAgents框架的核心特性，允许Agent使用多种工具来完成复杂任务。",
+                            "document_id":"agent_integration_guide"})
         
         rag_operations = [
             ("search", {
@@ -156,8 +158,8 @@ class AgentIntegrationDemo:
         ]
         
         for operation, params in rag_operations:
-            print(f"  操作: rag.execute('{operation}', {params})")
-            result = self.rag_tool.execute(operation, **params)
+            print(f"  操作: rag.run('{operation}', {params})")
+            result = self.rag_tool.run({"action":operation, **params})
             print(f"  结果: {str(result)[:100]}...")
     
     def demonstrate_collaborative_workflow(self):
@@ -192,65 +194,65 @@ class AgentIntegrationDemo:
 - 发布-订阅系统
 """
         
-        rag_result = self.rag_tool.execute("add_text",
-                                         text=learning_content,
-                                         document_id="observer_pattern")
+        rag_result = self.rag_tool.run({"action":"add_text",
+                                         "text":learning_content,
+                                         "document_id":"observer_pattern"})
         print(f"RAG添加结果: {rag_result}")
         
         # 记录学习活动到记忆系统
-        memory_result = self.memory_tool.execute("add",
-                                                content="学习了观察者设计模式的定义、结构和应用场景",
-                                                memory_type="episodic",
-                                                importance=0.8,
-                                                topic="design_patterns",
-                                                pattern_type="observer")
+        memory_result = self.memory_tool.run({"action":"add",
+                                                "content":"学习了观察者设计模式的定义、结构和应用场景",
+                                                "memory_type":"episodic",
+                                                "importance":0.8,
+                                                "topic":"design_patterns",
+                                                "pattern_type":"observer"})
         print(f"Memory记录结果: {memory_result}")
         
         # 场景2：回顾学习历程
         print(f"\n🔍 场景2：回顾学习历程")
         
         # 从记忆系统检索学习历史
-        memory_search = self.memory_tool.execute("search",
-                                                query="设计模式学习",
-                                                limit=3)
+        memory_search = self.memory_tool.run({"action":"search",
+                                                "query":"设计模式学习",
+                                                "limit":3})
         print(f"学习历史回顾: {memory_search}")
         
         # 从RAG获取相关知识补充
-        rag_search = self.rag_tool.execute("search",
-                                         query="观察者模式",
-                                         limit=2)
+        rag_search = self.rag_tool.run({"action":"search",
+                                         "query":"观察者模式",
+                                         "limit":2})
         print(f"知识内容补充: {rag_search}")
         
         # 场景3：知识应用
         print(f"\n💡 场景3：知识应用")
         
         # 通过RAG查询应用方法
-        application_query = self.rag_tool.execute("ask",
-                                                question="观察者模式适用于什么场景？",
-                                                limit=2)
+        application_query = self.rag_tool.run({"action":"ask",
+                                                "question":"观察者模式适用于什么场景？",
+                                                "limit":2})
         print(f"应用场景查询: {application_query}")
         
         # 记录应用实践到记忆
-        application_memory = self.memory_tool.execute("add",
-                                                     content="查询了观察者模式的应用场景，准备在GUI项目中使用",
-                                                     memory_type="working",
-                                                     importance=0.7,
-                                                     application_context="gui_project")
+        application_memory = self.memory_tool.run({"action":"add",
+                                                     "content":"查询了观察者模式的应用场景，准备在GUI项目中使用",
+                                                     "memory_type":"working",
+                                                     "importance":0.7,
+                                                     "application_context":"gui_project"})
         print(f"应用记录: {application_memory}")
         
         # 场景4：学习分析
         print(f"\n📊 场景4：学习分析")
         
         # 获取记忆系统统计
-        memory_stats = self.memory_tool.execute("stats")
+        memory_stats = self.memory_tool.run({"action":"stats"})
         print(f"记忆统计: {memory_stats}")
         
         # 获取RAG系统统计
-        rag_stats = self.rag_tool.execute("stats")
+        rag_stats = self.rag_tool.run({"action":"stats"})
         print(f"知识库统计: {rag_stats}")
         
         # 生成学习摘要
-        learning_summary = self.memory_tool.execute("summary", limit=5)
+        learning_summary = self.memory_tool.run({"action":"summary", "limit":5})
         print(f"学习摘要: {learning_summary}")
     
     def demonstrate_agent_orchestration(self):
@@ -290,48 +292,48 @@ class AgentIntegrationDemo:
 3. 前沿技术：最新论文、开源项目
 """
         
-        self.rag_tool.execute("add_text",
-                            text=ml_content,
-                            document_id="ml_learning_path")
+        self.rag_tool.run({"action":"add_text",
+                            "text":ml_content,
+                            "document_id":"ml_learning_path"})
         
-        knowledge_structure = self.rag_tool.execute("ask",
-                                                  question="机器学习的学习路径是什么？",
-                                                  limit=3)
+        knowledge_structure = self.rag_tool.run({"action":"ask",
+                                                  "question":"机器学习的学习路径是什么？",
+                                                  "limit":3})
         print(f"知识结构: {knowledge_structure[:200]}...")
         
         # 步骤2：记录学习计划到记忆系统
         print(f"\n步骤2: 记录学习计划")
         
-        plan_memory = self.memory_tool.execute("add",
-                                             content="制定了机器学习学习计划，包括基础、进阶、高级三个阶段",
-                                             memory_type="episodic",
-                                             importance=0.9,
-                                             plan_type="learning",
-                                             subject="machine_learning")
+        plan_memory = self.memory_tool.run({"action":"add",
+                                             "content":"制定了机器学习学习计划，包括基础、进阶、高级三个阶段",
+                                             "memory_type":"episodic",
+                                             "importance":0.9,
+                                             "plan_type":"learning",
+                                             "subject":"machine_learning"})
         print(f"计划记录: {plan_memory}")
         
         # 步骤3：检索相关学习经验
         print(f"\n步骤3: 检索学习经验")
         
-        experience_search = self.memory_tool.execute("search",
-                                                    query="学习计划 学习经验",
-                                                    limit=3)
+        experience_search = self.memory_tool.run({"action":"search",
+                                                    "query":"学习计划 学习经验",
+                                                    "limit":3})
         print(f"相关经验: {experience_search}")
         
         # 步骤4：整合生成最终建议
         print(f"\n步骤4: 生成最终建议")
         
-        final_advice = self.rag_tool.execute("ask",
-                                            question="如何制定有效的机器学习学习计划？",
-                                            limit=4)
+        final_advice = self.rag_tool.run({"action":"ask",
+                                            "question":"如何制定有效的机器学习学习计划？",
+                                            "limit":4})
         print(f"最终建议: {final_advice[:300]}...")
         
         # 记录编排过程
-        orchestration_memory = self.memory_tool.execute("add",
-                                                       content="完成了复杂的学习计划制定任务，使用了RAG和Memory的协同编排",
-                                                       memory_type="working",
-                                                       importance=0.8,
-                                                       task_type="orchestration")
+        orchestration_memory = self.memory_tool.run({"action":"add",
+                                                       "content":"完成了复杂的学习计划制定任务，使用了RAG和Memory的协同编排",
+                                                       "memory_type":"working",
+                                                       "importance":0.8,
+                                                       "task_type":"orchestration"})
         print(f"\n编排记录: {orchestration_memory}")
     
     def demonstrate_performance_analysis(self):
@@ -354,19 +356,19 @@ class AgentIntegrationDemo:
         # Memory工具性能
         start_time = time.time()
         for i in range(5):
-            self.memory_tool.execute("add",
-                                   content=f"性能测试记忆 {i+1}",
-                                   memory_type="working",
-                                   importance=0.5)
+            self.memory_tool.run({"action":"add",
+                                   "content":f"性能测试记忆 {i+1}",
+                                   "memory_type":"working",
+                                   "importance":0.5})
         memory_time = time.time() - start_time
         print(f"Memory工具 - 5次添加操作: {memory_time:.3f}秒")
         
         # RAG工具性能
         start_time = time.time()
         for i in range(3):
-            self.rag_tool.execute("search",
-                                query=f"测试查询 {i+1}",
-                                limit=2)
+            self.rag_tool.run({"action":"search",
+                                "query":f"测试查询 {i+1}",
+                                "limit":2})
         rag_time = time.time() - start_time
         print(f"RAG工具 - 3次搜索操作: {rag_time:.3f}秒")
         
@@ -376,22 +378,22 @@ class AgentIntegrationDemo:
         start_time = time.time()
         
         # 模拟协同工作流程
-        self.rag_tool.execute("add_text",
-                            text="这是一个性能测试文档",
-                            document_id="perf_test")
+        self.rag_tool.run({"action":"add_text",
+                            "text":"这是一个性能测试文档",
+                            "document_id":"perf_test"})
         
-        self.memory_tool.execute("add",
-                                content="执行了性能测试",
-                                memory_type="working",
-                                importance=0.6)
+        self.memory_tool.run({"action":"add",
+                                "content":"执行了性能测试",
+                                "memory_type":"working",
+                                "importance":0.6})
         
-        rag_result = self.rag_tool.execute("search",
-                                         query="性能测试",
-                                         limit=1)
+        rag_result = self.rag_tool.run({"action":"search",
+                                         "query":"性能测试",
+                                         "limit":1})
         
-        memory_result = self.memory_tool.execute("search",
-                                                query="性能测试",
-                                                limit=1)
+        memory_result = self.memory_tool.run({"action":"search",
+                                                "query":"性能测试",
+                                                "limit":1})
         
         collaborative_time = time.time() - start_time
         print(f"协同工作流程: {collaborative_time:.3f}秒")
@@ -403,8 +405,8 @@ class AgentIntegrationDemo:
         print(f"协同工作效率: {collaborative_time:.3f}秒/流程")
         
         # 获取最终统计
-        final_memory_stats = self.memory_tool.execute("stats")
-        final_rag_stats = self.rag_tool.execute("stats")
+        final_memory_stats = self.memory_tool.run({"action":"stats"})
+        final_rag_stats = self.rag_tool.run({"action":"stats"})
         
         print(f"\n📊 最终系统状态:")
         print(f"Memory系统: {final_memory_stats}")

code/chapter8/09_Memory_Types_Deep_Dive.py

@@ -11,6 +11,8 @@ import hashlib
 from datetime import datetime, timedelta
 from typing import List, Dict, Any, Optional
 from hello_agents.tools import MemoryTool
+from dotenv import load_dotenv
+load_dotenv()
 
 class MemoryTypesDeepDive:
     """四种记忆类型深度解析演示类"""
@@ -63,15 +65,15 @@ class MemoryTypesDeepDive:
         
         for i in range(8):
             content = f"临时工作记忆 {i+1}: 当前正在处理任务步骤 {i+1}"
-            result = self.working_memory_tool.execute("add",
-                                                    content=content,
-                                                    memory_type="working",
-                                                    importance=0.3 + (i * 0.1),
-                                                    task_step=i+1)
+            result = self.working_memory_tool.run({"action":"add",
+                                                    "content":content,
+                                                    "memory_type":"working",
+                                                    "importance":0.3 + (i * 0.1),
+                                                    "task_step":i+1})
             print(f"  添加记忆 {i+1}: {result}")
         
         # 检查当前状态
-        stats = self.working_memory_tool.execute("stats")
+        stats = self.working_memory_tool.run({"action":"stats"})
         print(f"\n当前工作记忆状态: {stats}")
         
         # 演示TTL机制
@@ -90,11 +92,11 @@ class MemoryTypesDeepDive:
         
         for content, minutes_ago, importance in time_memories:
             # 这里我们模拟时间差异
-            result = self.working_memory_tool.execute("add",
-                                                    content=content,
-                                                    memory_type="working",
-                                                    importance=importance,
-                                                    simulated_age_minutes=minutes_ago)
+            result = self.working_memory_tool.run({"action":"add",
+                                                    "content":content,
+                                                    "memory_type":"working",
+                                                    "importance":importance,
+                                                    "simulated_age_minutes":minutes_ago})
             print(f"  添加记忆: {content} (模拟 {minutes_ago} 分钟前)")
         
         # 演示快速检索
@@ -104,10 +106,10 @@ class MemoryTypesDeepDive:
         
         for query in search_queries:
             start_time = time.time()
-            results = self.working_memory_tool.execute("search",
-                                                     query=query,
-                                                     memory_type="working",
-                                                     limit=3)
+            results = self.working_memory_tool.run({"action":"search",
+                                                     "query":query,
+                                                     "memory_type":"working",
+                                                     "limit":3})
             search_time = time.time() - start_time
             print(f"  查询 '{query}': {search_time:.4f}秒")
             print(f"    结果: {results[:100]}...")
@@ -116,17 +118,17 @@ class MemoryTypesDeepDive:
         print(f"\n4. 自动清理机制:")
         
         # 获取清理前的统计
-        before_stats = self.working_memory_tool.execute("stats")
+        before_stats = self.working_memory_tool.run({"action":"stats"})
         print(f"清理前: {before_stats}")
         
         # 触发清理（通过遗忘低重要性记忆）
-        forget_result = self.working_memory_tool.execute("forget",
-                                                       strategy="importance_based",
-                                                       threshold=0.4)
+        forget_result = self.working_memory_tool.run({"action":"forget",
+                                                       "strategy":"importance_based",
+                                                       "threshold":0.4})
         print(f"清理结果: {forget_result}")
         
         # 获取清理后的统计
-        after_stats = self.working_memory_tool.execute("stats")
+        after_stats = self.working_memory_tool.run({"action":"stats"})
         print(f"清理后: {after_stats}")
     
     def demonstrate_episodic_memory(self):
@@ -184,30 +186,30 @@ class MemoryTypesDeepDive:
         session_id = f"learning_session_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
         
         for i, event in enumerate(learning_session):
-            result = self.episodic_memory_tool.execute("add",
-                                                     content=event["content"],
-                                                     memory_type="episodic",
-                                                     importance=event["importance"],
-                                                     session_id=session_id,
-                                                     sequence_number=i+1,
-                                                     **{k: v for k, v in event.items() if k not in ["content", "importance"]})
+            result = self.episodic_memory_tool.run({"action":"add",
+                                                     "content":event["content"],
+                                                     "memory_type":"episodic",
+                                                     "importance":event["importance"],
+                                                     "session_id":session_id,
+                                                     "sequence_number":i+1,
+                                                     **{k: v for k, v in event.items() if k not in ["content", "importance"]}})
             print(f"  事件 {i+1}: {result}")
         
         # 演示时间序列检索
         print(f"\n2. 时间序列检索演示:")
         
         # 按时间顺序检索
-        timeline_search = self.episodic_memory_tool.execute("search",
-                                                          query="学习",
-                                                          memory_type="episodic",
-                                                          limit=10)
+        timeline_search = self.episodic_memory_tool.run({"action":"search",
+                                                          "query":"学习",
+                                                          "memory_type":"episodic",
+                                                          "limit":10})
         print(f"学习时间线: {timeline_search}")
         
         # 按会话检索
-        session_search = self.episodic_memory_tool.execute("search",
-                                                         query="线性回归",
-                                                         memory_type="episodic",
-                                                         limit=5)
+        session_search = self.episodic_memory_tool.run({"action":"search",
+                                                         "query":"线性回归",
+                                                         "memory_type":"episodic",
+                                                         "limit":5})
         print(f"会话内容: {session_search}")
         
         # 演示上下文丰富性
@@ -230,11 +232,11 @@ class MemoryTypesDeepDive:
             "satisfaction_rating": 9
         }
         
-        context_result = self.episodic_memory_tool.execute("add",
-                                                         content=rich_context_memory["content"],
-                                                         memory_type="episodic",
-                                                         importance=0.9,
-                                                         **{k: v for k, v in rich_context_memory.items() if k != "content"})
+        context_result = self.episodic_memory_tool.run({"action":"add",
+                                                         "content":rich_context_memory["content"],
+                                                         "memory_type":"episodic",
+                                                         "importance":0.9,
+                                                         **{k: v for k, v in rich_context_memory.items() if k != "content"}})
         print(f"丰富上下文记忆: {context_result}")
         
         # 演示记忆链条
@@ -253,13 +255,13 @@ class MemoryTypesDeepDive:
         for content, chain_type, parent_type in memory_chain:
             parent_id = chain_memories.get(parent_type) if parent_type else None
             
-            result = self.episodic_memory_tool.execute("add",
-                                                     content=content,
-                                                     memory_type="episodic",
-                                                     importance=0.7,
-                                                     chain_type=chain_type,
-                                                     parent_memory=parent_id,
-                                                     chain_id="gpt_learning_chain")
+            result = self.episodic_memory_tool.run({"action":"add",
+                                                     "content":content,
+                                                     "memory_type":"episodic",
+                                                     "importance":0.7,
+                                                     "chain_type":chain_type,
+                                                     "parent_memory":parent_id,
+                                                     "chain_id":"gpt_learning_chain"})
             
             # 提取记忆ID（简化处理）
             memory_id = f"{chain_type}_memory"
@@ -267,10 +269,10 @@ class MemoryTypesDeepDive:
             print(f"  链条记忆: {content} (类型: {chain_type})")
         
         # 检索整个链条
-        chain_search = self.episodic_memory_tool.execute("search",
-                                                        query="GPT Transformer",
-                                                        memory_type="episodic",
-                                                        limit=8)
+        chain_search = self.episodic_memory_tool.run({"action":"search",
+                                                        "query":"GPT Transformer",
+                                                        "memory_type":"episodic",
+                                                        "limit":8})
         print(f"记忆链条检索: {chain_search}")
     
     def demonstrate_semantic_memory(self):
@@ -323,11 +325,11 @@ class MemoryTypesDeepDive:
         ]
         
         for concept in concepts:
-            result = self.semantic_memory_tool.execute("add",
-                                                     content=concept["content"],
-                                                     memory_type="semantic",
-                                                     importance=concept["importance"],
-                                                     **{k: v for k, v in concept.items() if k not in ["content", "importance"]})
+            result = self.semantic_memory_tool.run({"action":"add",
+                                                     "content":concept["content"],
+                                                     "memory_type":"semantic",
+                                                     "importance":concept["importance"],
+                                                     **{k: v for k, v in concept.items() if k not in ["content", "importance"]}})
             print(f"  概念存储: {concept['concept_type']} - {result}")
         
         # 演示关系推理
@@ -359,11 +361,11 @@ class MemoryTypesDeepDive:
         ]
         
         for relation in relationships:
-            result = self.semantic_memory_tool.execute("add",
-                                                     content=relation["content"],
-                                                     memory_type="semantic",
-                                                     importance=0.8,
-                                                     **{k: v for k, v in relation.items() if k != "content"})
+            result = self.semantic_memory_tool.run({"action":"add",
+                                                     "content":relation["content"],
+                                                     "memory_type":"semantic",
+                                                     "importance":0.8,
+                                                     **{k: v for k, v in relation.items() if k != "content"}})
             print(f"  关系存储: {relation['relation_type']} - {result}")
         
         # 演示语义检索
@@ -378,10 +380,10 @@ class MemoryTypesDeepDive:
         
         for query in semantic_queries:
             start_time = time.time()
-            results = self.semantic_memory_tool.execute("search",
-                                                      query=query,
-                                                      memory_type="semantic",
-                                                      limit=3)
+            results = self.semantic_memory_tool.run({"action":"search",
+                                                      "query":query,
+                                                      "memory_type":"semantic",
+                                                      "limit":3})
             search_time = time.time() - start_time
             print(f"  查询: '{query}' ({search_time:.4f}秒)")
             print(f"    结果: {results[:150]}...")
@@ -417,15 +419,15 @@ class MemoryTypesDeepDive:
         ]
         
         for item in entities_and_relations:
-            result = self.semantic_memory_tool.execute("add",
-                                                     content=item["content"],
-                                                     memory_type="semantic",
-                                                     importance=0.8,
-                                                     **{k: v for k, v in item.items() if k != "content"})
+            result = self.semantic_memory_tool.run({"action":"add",
+                                                     "content":item["content"],
+                                                     "memory_type":"semantic",
+                                                     "importance":0.8,
+                                                     **{k: v for k, v in item.items() if k != "content"}})
             print(f"  实体关系: {item['entity_type']} - {result}")
         
         # 获取语义记忆统计
-        semantic_stats = self.semantic_memory_tool.execute("stats")
+        semantic_stats = self.semantic_memory_tool.run({"action":"stats"})
         print(f"\n语义记忆统计: {semantic_stats}")
     
     def demonstrate_perceptual_memory(self):
@@ -462,11 +464,11 @@ class MemoryTypesDeepDive:
         ]
         
         for perception in text_perceptions:
-            result = self.perceptual_memory_tool.execute("add",
-                                                       content=perception["content"],
-                                                       memory_type="perceptual",
-                                                       importance=0.7,
-                                                       **{k: v for k, v in perception.items() if k != "content"})
+            result = self.perceptual_memory_tool.run({"action":"add",
+                                                       "content":perception["content"],
+                                                       "memory_type":"perceptual",
+                                                       "importance":0.7,
+                                                       **{k: v for k, v in perception.items() if k != "content"}})
             print(f"  文本感知: {perception['genre']} - {result}")
         
         # 演示图像感知记忆（模拟）
@@ -496,12 +498,12 @@ class MemoryTypesDeepDive:
         ]
         
         for perception in image_perceptions:
-            result = self.perceptual_memory_tool.execute("add",
-                                                       content=perception["content"],
-                                                       memory_type="perceptual",
-                                                       importance=0.8,
-                                                       **{k: v for k, v in perception.items() if k != "content"})
-            print(f"  图像感知: {perception['scene_type']} - {result}")
+            result = self.perceptual_memory_tool.run({"action":"add",
+                                                       "content":perception["content"],
+                                                       "memory_type":"perceptual",
+                                                       "importance":0.8,
+                                                       **{k: v for k, v in perception.items() if k != "content"}})
+            print(f"  图像感知: {perception['content']} - {result}")
         
         # 演示音频感知记忆（模拟）
         print(f"\n3. 音频感知记忆（模拟）:")
@@ -530,12 +532,12 @@ class MemoryTypesDeepDive:
         ]
         
         for perception in audio_perceptions:
-            result = self.perceptual_memory_tool.execute("add",
-                                                       content=perception["content"],
-                                                       memory_type="perceptual",
-                                                       importance=0.7,
-                                                       **{k: v for k, v in perception.items() if k != "content"})
-            print(f"  音频感知: {perception['genre']} - {result}")
+            result = self.perceptual_memory_tool.run({"action":"add",
+                                                       "content":perception["content"],
+                                                       "memory_type":"perceptual",
+                                                       "importance":0.7,
+                                                       **{k: v for k, v in perception.items() if k != "content"}})
+            print(f"  音频感知: {perception['content']} - {result}")
         
         # 演示跨模态检索
         print(f"\n4. 跨模态检索演示:")
@@ -548,10 +550,10 @@ class MemoryTypesDeepDive:
         ]
         
         for query, description in cross_modal_queries:
-            results = self.perceptual_memory_tool.execute("search",
-                                                        query=query,
-                                                        memory_type="perceptual",
-                                                        limit=3)
+            results = self.perceptual_memory_tool.run({"action":"search",
+                                                        "query":query,
+                                                        "memory_type":"perceptual",
+                                                        "limit":3})
             print(f"  跨模态查询: '{query}' ({description})")
             print(f"    结果: {results[:120]}...")
         
@@ -559,14 +561,14 @@ class MemoryTypesDeepDive:
         print(f"\n5. 感知特征分析:")
         
         # 获取感知记忆统计
-        perceptual_stats = self.perceptual_memory_tool.execute("stats")
+        perceptual_stats = self.perceptual_memory_tool.run({"action":"stats"})
         print(f"感知记忆统计: {perceptual_stats}")
         
         # 分析不同模态的分布
-        modality_analysis = self.perceptual_memory_tool.execute("search",
-                                                              query="模态分析",
-                                                              memory_type="perceptual",
-                                                              limit=10)
+        modality_analysis = self.perceptual_memory_tool.run({"action":"search",
+                                                              "query":"模态分析",
+                                                              "memory_type":"perceptual",
+                                                              "limit":10})
         print(f"模态分布分析: {modality_analysis}")
     
     def demonstrate_memory_interactions(self):
@@ -586,14 +588,14 @@ class MemoryTypesDeepDive:
         # 1. 感知阶段：接收多模态信息
         print(f"\n1. 感知阶段 - 接收信息:")
         
-        perceptual_input = self.perceptual_memory_tool.execute("add",
-                                                             content="观看了一个关于深度学习的视频教程",
-                                                             memory_type="perceptual",
-                                                             importance=0.8,
-                                                             modality="video",
-                                                             topic="deep_learning",
-                                                             duration_minutes=45,
-                                                             quality="high")
+        perceptual_input = self.perceptual_memory_tool.run({"action":"add",
+                                                             "content":"观看了一个关于深度学习的视频教程",
+                                                             "memory_type":"perceptual",
+                                                             "importance":0.8,
+                                                             "modality":"video",
+                                                             "topic":"deep_learning",
+                                                             "duration_minutes":45,
+                                                             "quality":"high"})
         print(f"感知记忆: {perceptual_input}")
         
         # 2. 工作记忆阶段：临时处理和思考
@@ -607,25 +609,25 @@ class MemoryTypesDeepDive:
         ]
         
         for thought in working_thoughts:
-            result = self.working_memory_tool.execute("add",
-                                                    content=thought,
-                                                    memory_type="working",
-                                                    importance=0.6,
-                                                    processing_stage="active_thinking")
+            result = self.working_memory_tool.run({"action":"add",
+                                                    "content":thought,
+                                                    "memory_type":"working",
+                                                    "importance":0.6,
+                                                    "processing_stage":"active_thinking"})
             print(f"  工作记忆: {thought[:30]}... - {result}")
         
         # 3. 情景记忆阶段：记录完整学习事件
         print(f"\n3. 情景记忆阶段 - 事件记录:")
         
-        episodic_event = self.episodic_memory_tool.execute("add",
-                                                         content="完成了深度学习视频教程的学习，理解了CNN的核心概念",
-                                                         memory_type="episodic",
-                                                         importance=0.9,
-                                                         event_type="learning_session",
-                                                         duration_minutes=45,
-                                                         location="家里",
-                                                         learning_outcome="理解CNN原理",
-                                                         next_action="实践编程")
+        episodic_event = self.episodic_memory_tool.run({"action":"add",
+                                                         "content":"完成了深度学习视频教程的学习，理解了CNN的核心概念",
+                                                         "memory_type":"episodic",
+                                                         "importance":0.9,
+                                                         "event_type":"learning_session",
+                                                         "duration_minutes":45,
+                                                         "location":"家里",
+                                                         "learning_outcome":"理解CNN原理",
+                                                         "next_action":"实践编程"})
         print(f"情景记忆: {episodic_event}")
         
         # 4. 语义记忆阶段：抽象知识存储
@@ -647,21 +649,21 @@ class MemoryTypesDeepDive:
         ]
         
         for knowledge in semantic_knowledge:
-            result = self.semantic_memory_tool.execute("add",
-                                                     content=knowledge["content"],
-                                                     memory_type="semantic",
-                                                     importance=0.8,
-                                                     **{k: v for k, v in knowledge.items() if k != "content"})
+            result = self.semantic_memory_tool.run({"action":"add",
+                                                     "content":knowledge["content"],
+                                                     "memory_type":"semantic",
+                                                     "importance":0.8,
+                                                     **{k: v for k, v in knowledge.items() if k != "content"}})
             print(f"  语义记忆: {knowledge['concept']} - {result}")
         
         # 5. 记忆整合演示
         print(f"\n5. 记忆整合演示:")
         
         # 从工作记忆整合到情景记忆
-        consolidation_result = self.working_memory_tool.execute("consolidate",
-                                                              from_type="working",
-                                                              to_type="episodic",
-                                                              importance_threshold=0.6)
+        consolidation_result = self.working_memory_tool.run({"action":"consolidate",
+                                                              "from_type":"working",
+                                                              "to_type":"episodic",
+                                                              "importance_threshold":0.6})
         print(f"工作记忆整合: {consolidation_result}")
         
         # 跨记忆类型检索
@@ -678,14 +680,14 @@ class MemoryTypesDeepDive:
         ]
         
         for memory_name, tool in memory_tools:
-            results = tool.execute("search", query=query, limit=2)
+            results = tool.run({"action":"search", "query":query, "limit":2})
             print(f"  {memory_name}检索: {results[:80]}...")
         
         # 获取所有记忆系统的统计
         print(f"\n7. 系统整体状态:")
         
         for memory_name, tool in memory_tools:
-            stats = tool.execute("stats")
+            stats = tool.run({"action":"stats"})
             print(f"  {memory_name}: {stats}")
 
 def main():

code/chapter8/10_RAG_Pipeline_Complete.py

@@ -11,6 +11,8 @@ import json
 from datetime import datetime
 from typing import List, Dict, Any, Optional
 from hello_agents.tools import RAGTool
+from dotenv import load_dotenv
+load_dotenv()
 
 class RAGPipelineComplete:
     """RAG完整处理管道演示类"""
@@ -193,10 +195,10 @@ class RAGPipelineComplete:
         for doc in documents:
             print(f"\n处理文档: {doc['document_id']} ({doc['format']})")
             
-            result = self.rag_tool.execute("add_text",
-                                         text=doc["content"],
-                                         document_id=doc["document_id"],
-                                         **doc["metadata"])
+            result = self.rag_tool.run({"action":"add_text",
+                                         "text":doc["content"],
+                                         "document_id":doc["document_id"],
+                                         **doc["metadata"]})
             print(f"  摄取结果: {result}")
             
             # 显示文档统计
@@ -252,17 +254,17 @@ class RAGPipelineComplete:
         # 批量处理
         start_time = time.time()
         for doc in batch_documents:
-            result = self.rag_tool.execute("add_text",
-                                         text=doc["content"],
-                                         document_id=doc["document_id"],
-                                         **doc["metadata"])
+            result = self.rag_tool.run({"action":"add_text",
+                                         "text":doc["content"],
+                                         "document_id":doc["document_id"],
+                                         **doc["metadata"]})
             print(f"  批量处理 {doc['document_id']}: {result}")
         
         batch_time = time.time() - start_time
         print(f"  批量处理耗时: {batch_time:.3f}秒")
         
         # 获取摄取统计
-        stats = self.rag_tool.execute("stats")
+        stats = self.rag_tool.run({"action":"stats"})
         print(f"\n📊 文档摄取统计: {stats}")
     
     def demonstrate_chunking_strategies(self):
@@ -343,12 +345,12 @@ class RAGPipelineComplete:
 """
         
         # 添加长文档并观察分块效果
-        chunking_result = self.rag_tool.execute("add_text",
-                                               text=long_document,
-                                               document_id="ai_history_long",
-                                               title="人工智能发展史",
-                                               type="historical_overview",
-                                               chunking_strategy="semantic")
+        chunking_result = self.rag_tool.run({"action":"add_text",
+                                               "text":long_document,
+                                               "document_id":"ai_history_long",
+                                               "title":"人工智能发展史",
+                                               "type":"historical_overview",
+                                               "chunking_strategy":"semantic"})
         print(f"长文档分块结果: {chunking_result}")
         
         # 演示不同分块大小的影响
@@ -364,9 +366,9 @@ class RAGPipelineComplete:
         
         for query in test_queries:
             start_time = time.time()
-            results = self.rag_tool.execute("search",
-                                          query=query,
-                                          limit=3)
+            results = self.rag_tool.run({"action":"search",
+                                          "query":query,
+                                          "limit":3})
             search_time = time.time() - start_time
             print(f"  查询: '{query}' ({search_time:.4f}秒)")
             print(f"    结果: {results[:120]}...")
@@ -416,12 +418,12 @@ class RAGPipelineComplete:
 **应用场景**: 数据可视化、特征提取
 """
         
-        structured_result = self.rag_tool.execute("add_text",
-                                                 text=structured_doc,
-                                                 document_id="ml_algorithms_handbook",
-                                                 title="机器学习算法手册",
-                                                 type="reference_manual",
-                                                 structure="hierarchical")
+        structured_result = self.rag_tool.run({"action":"add_text",
+                                                 "text":structured_doc,
+                                                 "document_id":"ml_algorithms_handbook",
+                                                 "title":"机器学习算法手册",
+                                                 "type":"reference_manual",
+                                                 "structure":"hierarchical"})
         print(f"结构化文档分块: {structured_result}")
         
         # 测试结构化检索
@@ -432,9 +434,9 @@ class RAGPipelineComplete:
         ]
         
         for query in structured_queries:
-            results = self.rag_tool.execute("search",
-                                          query=query,
-                                          limit=2)
+            results = self.rag_tool.run({"action":"search",
+                                          "query":query,
+                                          "limit":2})
             print(f"  结构化查询 '{query}': {results[:100]}...")
     
     def demonstrate_advanced_retrieval(self):
@@ -469,9 +471,9 @@ class RAGPipelineComplete:
         # 执行多查询检索
         all_results = []
         for query in [base_query] + expanded_queries:
-            results = self.rag_tool.execute("search",
-                                          query=query,
-                                          limit=3)
+            results = self.rag_tool.run({"action":"search",
+                                          "query":query,
+                                          "limit":3})
             all_results.append((query, results))
             print(f"  查询结果 '{query[:20]}...': {results[:80]}...")
         
@@ -487,15 +489,15 @@ class RAGPipelineComplete:
         print(f"假设答案: {hypothetical_answer[:100]}...")
         
         # 使用假设答案进行检索
-        hyde_results = self.rag_tool.execute("search",
-                                           query=hypothetical_answer,
-                                           limit=5)
+        hyde_results = self.rag_tool.run({"action":"search",
+                                           "query":hypothetical_answer,
+                                           "limit":5})
         print(f"HyDE检索结果: {hyde_results[:120]}...")
         
         # 对比直接查询结果
-        direct_results = self.rag_tool.execute("search",
-                                             query=user_question,
-                                             limit=5)
+        direct_results = self.rag_tool.run({"action":"search",
+                                             "query":user_question,
+                                             "limit":5})
         print(f"直接查询结果: {direct_results[:120]}...")
         
         # 演示混合检索策略
@@ -516,9 +518,9 @@ class RAGPipelineComplete:
         print(f"查询分解:")
         mixed_results = {}
         for sub_query in sub_queries:
-            results = self.rag_tool.execute("search",
-                                          query=sub_query,
-                                          limit=2)
+            results = self.rag_tool.run({"action":"search",
+                                          "query":sub_query,
+                                          "limit":2})
             mixed_results[sub_query] = results
             print(f"  子查询: {sub_query}")
             print(f"    结果: {results[:80]}...")
@@ -530,9 +532,9 @@ class RAGPipelineComplete:
         print(f"排序查询: {ranking_query}")
         
         # 获取初始结果
-        initial_results = self.rag_tool.execute("search",
-                                              query=ranking_query,
-                                              limit=8)
+        initial_results = self.rag_tool.run({"action":"search",
+                                              "query":ranking_query,
+                                              "limit":8})
         print(f"初始检索结果: {initial_results[:150]}...")
         
         # 模拟重排序过程（基于多个因素）
@@ -542,9 +544,9 @@ class RAGPipelineComplete:
         print(f"  • 文档权威性权重: 0.2")
         
         # 最终排序结果
-        final_results = self.rag_tool.execute("search",
-                                            query=ranking_query,
-                                            limit=5)
+        final_results = self.rag_tool.run({"action":"search",
+                                            "query":ranking_query,
+                                            "limit":5})
         print(f"重排序后结果: {final_results[:150]}...")
     
     def demonstrate_intelligent_qa(self):
@@ -596,9 +598,9 @@ class RAGPipelineComplete:
             
             # 执行问答
             start_time = time.time()
-            answer = self.rag_tool.execute("ask",
-                                         question=example["question"],
-                                         limit=4)
+            answer = self.rag_tool.run({"action":"ask",
+                                         "question":example["question"],
+                                         "limit":4})
             qa_time = time.time() - start_time
             
             print(f"回答 ({qa_time:.3f}秒): {answer[:200]}...")
@@ -617,15 +619,15 @@ class RAGPipelineComplete:
         print(f"  4. 上下文排序 - 按相关性和重要性排序")
         
         # 执行上下文构建
-        context_search = self.rag_tool.execute("search",
-                                             query="神经网络过拟合防止方法",
-                                             limit=6)
+        context_search = self.rag_tool.run({"action":"search",
+                                             "query":"神经网络过拟合防止方法",
+                                             "limit":6})
         print(f"  检索到的上下文: {context_search[:180]}...")
         
         # 生成最终答案
-        final_answer = self.rag_tool.execute("ask",
-                                           question=context_question,
-                                           limit=5)
+        final_answer = self.rag_tool.run({"action":"ask",
+                                           "question":context_question,
+                                           "limit":5})
         print(f"  最终答案: {final_answer[:250]}...")
         
         # 演示多轮对话支持
@@ -648,9 +650,9 @@ class RAGPipelineComplete:
             else:
                 context_query = question
             
-            answer = self.rag_tool.execute("ask",
-                                         question=context_query,
-                                         limit=3)
+            answer = self.rag_tool.run({"action":"ask",
+                                         "question":context_query,
+                                         "limit":3})
             print(f"  回答: {answer[:150]}...")
         
         # 演示答案质量评估
@@ -659,9 +661,9 @@ class RAGPipelineComplete:
         quality_question = "解释反向传播算法的工作原理"
         print(f"评估问题: {quality_question}")
         
-        answer = self.rag_tool.execute("ask",
-                                     question=quality_question,
-                                     limit=5)
+        answer = self.rag_tool.run({"action":"ask",
+                                     "question":quality_question,
+                                     "limit":5})
         
         print(f"生成答案: {answer[:300]}...")
         
@@ -707,9 +709,9 @@ class RAGPipelineComplete:
         
         for i, query in enumerate(performance_queries, 1):
             start_time = time.time()
-            results = self.rag_tool.execute("search",
-                                          query=query,
-                                          limit=5)
+            results = self.rag_tool.run({"action":"search",
+                                          "query":query,
+                                          "limit":5})
             query_time = time.time() - start_time
             total_time += query_time
             
@@ -736,7 +738,7 @@ class RAGPipelineComplete:
         start_time = time.time()
         individual_results = []
         for query in batch_queries:
-            result = self.rag_tool.execute("search", query=query, limit=2)
+            result = self.rag_tool.run({"action":"search", "query":query, "limit":2})
             individual_results.append(result)
         individual_time = time.time() - start_time
         
@@ -746,7 +748,7 @@ class RAGPipelineComplete:
         start_time = time.time()
         batch_results = []
         for query in batch_queries:
-            result = self.rag_tool.execute("search", query=query, limit=2)
+            result = self.rag_tool.run({"action":"search", "query":query, "limit":2})
             batch_results.append(result)
         batch_time = time.time() - start_time
         
@@ -760,17 +762,17 @@ class RAGPipelineComplete:
         
         # 第一次查询（无缓存）
         start_time = time.time()
-        first_result = self.rag_tool.execute("search",
-                                           query=cache_query,
-                                           limit=3)
+        first_result = self.rag_tool.run({"action":"search",
+                                           "query":cache_query,
+                                           "limit":3})
         first_time = time.time() - start_time
         print(f"  首次查询: {first_time:.4f}秒")
         
         # 第二次查询（可能有缓存）
         start_time = time.time()
-        second_result = self.rag_tool.execute("search",
-                                            query=cache_query,
-                                            limit=3)
+        second_result = self.rag_tool.run({"action":"search",
+                                            "query":cache_query,
+                                            "limit":3})
         second_time = time.time() - start_time
         print(f"  重复查询: {second_time:.4f}秒")
         
@@ -782,7 +784,7 @@ class RAGPipelineComplete:
         print(f"\n4. 系统监控:")
         
         # 获取系统统计
-        system_stats = self.rag_tool.execute("stats")
+        system_stats = self.rag_tool.run({"action":"stats"})
         print(f"  系统统计: {system_stats}")
         
         # 模拟资源使用监控

code/chapter8/11_Q&A_Assistant.py

@@ -17,7 +17,8 @@ from datetime import datetime
 from typing import Dict, List, Optional, Any, Tuple
 from hello_agents.tools import MemoryTool, RAGTool
 import gradio as gr
-
+from dotenv import load_dotenv
+load_dotenv()
 
 class PDFLearningAssistant:
     """智能文档问答助手"""
@@ -62,12 +63,12 @@ class PDFLearningAssistant:
 
         try:
             # 使用RAG工具处理PDF
-            result = self.rag_tool.execute(
-                "add_document",
-                file_path=pdf_path,
-                chunk_size=1000,
-                chunk_overlap=200
-            )
+            result = self.rag_tool.run({
+                "action":"add_document",
+                "file_path":pdf_path,
+                "chunk_size":1000,
+                "chunk_overlap":200
+            })
 
             process_time = time.time() - start_time
 
@@ -76,14 +77,14 @@ class PDFLearningAssistant:
             self.stats["documents_loaded"] += 1
 
             # 记录到学习记忆
-            self.memory_tool.execute(
-                "add",
-                content=f"加载了文档《{self.current_document}》",
-                memory_type="episodic",
-                importance=0.9,
-                event_type="document_loaded",
-                session_id=self.session_id
-            )
+            self.memory_tool.run({
+                "action":"add",
+                "content":f"加载了文档《{self.current_document}》",
+                "memory_type":"episodic",
+                "importance":0.9,
+                "event_type":"document_loaded",
+                "session_id":self.session_id
+            })
 
             return {
                 "success": True,
@@ -110,33 +111,33 @@ class PDFLearningAssistant:
             return "⚠️ 请先加载文档！使用 load_document() 方法加载PDF文档。"
 
         # 记录问题到工作记忆
-        self.memory_tool.execute(
-            "add",
-            content=f"提问: {question}",
-            memory_type="working",
-            importance=0.6,
-            session_id=self.session_id
-        )
+        self.memory_tool.run({
+            "action":"add",
+            "content":f"提问: {question}",
+            "memory_type":"working",
+            "importance":0.6,
+            "session_id":self.session_id
+        })
 
         # 使用RAG检索答案
-        answer = self.rag_tool.execute(
-            "ask",
-            question=question,
-            limit=5,
-            enable_advanced_search=use_advanced_search,
-            enable_mqe=use_advanced_search,
-            enable_hyde=use_advanced_search
-        )
+        answer = self.rag_tool.run({
+            "action":"ask",
+            "question":question,
+            "limit":5,
+            "enable_advanced_search":use_advanced_search,
+            "enable_mqe":use_advanced_search,
+            "enable_hyde":use_advanced_search
+        })
 
         # 记录到情景记忆
-        self.memory_tool.execute(
-            "add",
-            content=f"关于'{question}'的学习",
-            memory_type="episodic",
-            importance=0.7,
-            event_type="qa_interaction",
-            session_id=self.session_id
-        )
+        self.memory_tool.run({
+            "action":"add",
+            "content":f"关于'{question}'的学习",
+            "memory_type":"episodic",
+            "importance":0.7,
+            "event_type":"qa_interaction",
+            "session_id":self.session_id
+        })
 
         self.stats["questions_asked"] += 1
 
@@ -149,14 +150,14 @@ class PDFLearningAssistant:
             content: 笔记内容
             concept: 相关概念（可选）
         """
-        self.memory_tool.execute(
-            "add",
-            content=content,
-            memory_type="semantic",
-            importance=0.8,
-            concept=concept or "general",
-            session_id=self.session_id
-        )
+        self.memory_tool.run({
+            "action":"add",
+            "content":content,
+            "memory_type":"semantic",
+            "importance":0.8,
+            "concept":concept or "general",
+            "session_id":self.session_id
+        })
 
         self.stats["concepts_learned"] += 1
 
@@ -170,11 +171,11 @@ class PDFLearningAssistant:
         Returns:
             str: 相关记忆
         """
-        result = self.memory_tool.execute(
-            "search",
-            query=query,
-            limit=limit
-        )
+        result = self.memory_tool.run({
+            "action":"search",
+            "query":query,
+            "limit":limit
+        })
         return result
 
     def get_stats(self) -> Dict[str, Any]:
@@ -203,10 +204,10 @@ class PDFLearningAssistant:
             Dict: 学习报告
         """
         # 获取记忆摘要
-        memory_summary = self.memory_tool.execute("summary", limit=10)
+        memory_summary = self.memory_tool.run({"action":"summary", "limit":10})
 
         # 获取RAG统计
-        rag_stats = self.rag_tool.execute("stats")
+        rag_stats = self.rag_tool.run({"action":"stats"})
 
         # 生成报告
         duration = (datetime.now() - self.stats["session_start"]).total_seconds()