Upload 7 files

app.py

@@ -3,39 +3,41 @@ import os
 import time
 
 # ------------------------------------------------------------------
-# 1. 加载环境变量
+# 1. Load Environment Variables
 # ------------------------------------------------------------------
 api_key = os.environ.get("GEMINI_API_KEY")
 if not api_key:
-    print("警告：未找到 GEMINI_API_KEY。请在Hugging Face Spaces的Secrets中设置它。")
+    print(
+        "Warning: GEMINI_API_KEY not found. Please set it in your Hugging Face Spaces Secrets."
+    )
 
 # ------------------------------------------------------------------
-# 2. 初始化后端
+# 2. Initialize Backend
 # ------------------------------------------------------------------
-print("--- 正在启动 FeiMatrix Synapse 系统 ---")
+print("--- Starting FeiMatrix Synapse System ---")
 try:
     from database.setup import initialize_system
     from core.agent import SmartAIAgent
 
-    print("核心模块导入成功。")
+    print("Core modules imported successfully.")
 
     registered_tools, tool_recommender = initialize_system()
-    print("系统数据库和工具推荐器初始化完成。")
+    print("System database and tool recommender initialized successfully.")
     agent = SmartAIAgent(
         tool_recommender=tool_recommender,
         registered_tools=registered_tools,
         api_key=api_key,
     )
-    print("AI 智能体核心已成功创建。")
+    print("AI Agent Core created successfully.")
 except Exception as e:
-    print(f"系统初始化过程中发生严重错误: {e}")
+    print(f"A critical error occurred during system initialization: {e}")
     agent = None
 
-print("--- FeiMatrix Synapse 已准备就绪 ---")
+print("--- FeiMatrix Synapse is ready ---")
 
 
 # ------------------------------------------------------------------
-# 3. Gradio 事件处理函数
+# 3. Gradio Event Handler Functions
 # ------------------------------------------------------------------
 def handle_user_message(user_input, history):
     if not user_input.strip():
@@ -72,7 +74,7 @@ def generate_bot_response(history):
 
 
 # ------------------------------------------------------------------
-# 4. 创建 Gradio 界面
+# 4. Create Gradio Interface
 # ------------------------------------------------------------------
 custom_css = """
 #chatbot .message-bubble-content { color: #000000 !important; }
@@ -87,7 +89,6 @@ with gr.Blocks(
     title="FeiMatrix Synapse",
 ) as demo:
 
-    # --- 界面文本已全部修改为英文 ---
     gr.Markdown(
         """
         # 🚀 FeiMatrix Synapse - Intelligent AI Assistant
@@ -154,13 +155,13 @@ with gr.Blocks(
         elem_classes="footer",
     )
 
-    # --- 对话事件的触发流程 (保持不变) ---
     submit_event = text_input.submit(
         fn=handle_user_message,
         inputs=[text_input, chatbot],
         outputs=[text_input, chatbot],
         queue=False,
     ).then(fn=generate_bot_response, inputs=[chatbot], outputs=[chatbot])
+
     submit_button.click(
         fn=handle_user_message,
         inputs=[text_input, chatbot],
@@ -169,7 +170,7 @@ with gr.Blocks(
     ).then(fn=generate_bot_response, inputs=[chatbot], outputs=[chatbot])
 
 # ------------------------------------------------------------------
-# 5. 启动应用
+# 5. Launch the Application
 # ------------------------------------------------------------------
 if __name__ == "__main__":
     demo.queue()

core/agent.py

@@ -3,32 +3,32 @@ from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
 from typing import List, Any
 import json
 import os
-import re  # 导入正则表达式库
+import re
 
 from .tool_recommender import DirectToolRecommender
 from tools.tool_registry import get_tool_by_name
 
-# Agent的思考模板 (保持不变)
+# --- Agent Prompt, now fully in English ---
 AGENT_PROMPT_TEMPLATE = """
-你是一个强大的AI助理。你的任务是理解用户的问题，并决定是否需要使用工具来回答。
+You are a powerful AI assistant. Your task is to understand the user's question and decide if a tool is needed to answer it.
 
-你有以下工具可用：
+You have the following tools available:
 {tools}
 
-如果需要使用工具，请严格按照以下JSON格式进行响应，不要包含任何其他文本或解释：
+If you need to use a tool, you must respond in the following JSON format strictly, without any other text or explanation:
 {{
-  "tool": "要调用的工具名称",
-  "tool_input": {{ "参数1": "值1", "参数2": "值2" }}
+  "tool": "the_name_of_the_tool_to_call",
+  "tool_input": {{ "parameter1": "value1", "parameter2": "value2" }}
 }}
 
-如果不需要使用任何工具，请直接回答用户的问题。
+If you do not need to use any tool, answer the user's question directly.
 
-这是对话历史：
+This is the conversation history:
 {chat_history}
 
-用户问题：{input}
+User's question: {input}
 
-现在，请你思考并作出回应（JSON或直接回答）：
+Now, think and provide your response (either JSON or a direct answer):
 """
 
 
@@ -48,35 +48,28 @@ class SmartAIAgent:
             convert_system_message_to_human=True,
         )
         self.chat_history = []
-        print(f"LangChain Agent已初始化，使用模型: {self.model_name}。")
+        print(f"LangChain Agent initialized, using model: {self.model_name}.")
 
-    # ------------------- 核心修复在这里！ -------------------
-    # 我们添加一个更健壮的JSON提取函数
     def _extract_json_from_string(self, text: str) -> dict | None:
-        """从可能包含其他文本的字符串中提取出JSON块。"""
-        # 匹配被 markdown 包裹的JSON
+        """Extracts a JSON block from a string that might contain other text."""
         match = re.search(r"```json\s*(\{.*?\})\s*```", text, re.DOTALL)
         if match:
             json_str = match.group(1)
         else:
-            # 匹配裸露的JSON
             match = re.search(r"\{.*\}", text, re.DOTALL)
             if match:
                 json_str = match.group(0)
             else:
                 return None
-
         try:
             return json.loads(json_str)
         except json.JSONDecodeError:
             return None
 
-    # ----------------------------------------------------
-
     def _format_tools_for_prompt(self, tools: List[dict]) -> str:
-        # ... (此函数保持不变) ...
+        """Formats the list of tools into a clear string for the prompt."""
         if not tools:
-            return "没有可用的工具。"
+            return "No tools available."
         tool_strings = []
         for tool in tools:
             try:
@@ -85,44 +78,45 @@ class SmartAIAgent:
                     [f"{p_name}: {p_type}" for p_name, p_type in params.items()]
                 )
                 tool_strings.append(
-                    f"- 工具名称: {tool['name']}\n  - 描述: {tool['description']}\n  - 参数: {param_str}"
+                    f"- Tool Name: {tool['name']}\n  - Description: {tool['description']}\n  - Parameters: {param_str}"
                 )
             except (json.JSONDecodeError, TypeError):
                 tool_strings.append(
-                    f"- 工具名称: {tool['name']}\n  - 描述: {tool['description']}\n  - 参数: 无法解析"
+                    f"- Tool Name: {tool['name']}\n  - Description: {tool['description']}\n  - Parameters: Could not be parsed"
                 )
         return "\n".join(tool_strings)
 
     def _format_chat_history(self) -> str:
-        # ... (此函数保持不变) ...
+        """Formats the chat history for the prompt."""
         formatted_history = []
         for msg in self.chat_history:
             if isinstance(msg, HumanMessage):
-                formatted_history.append(f"用户: {msg.content}")
+                formatted_history.append(f"User: {msg.content}")
             elif isinstance(msg, AIMessage):
-                formatted_history.append(f"助理: {msg.content}")
+                formatted_history.append(f"Assistant: {msg.content}")
             elif isinstance(msg, ToolMessage):
-                formatted_history.append(f"工具结果: {msg.content}")
+                formatted_history.append(f"Tool Result: {msg.content}")
         return "\n".join(formatted_history)
 
     def stream_run(self, user_input: str):
+        """Processes user input in a streaming fashion."""
         self.chat_history.append(HumanMessage(content=user_input))
-        yield "🤔 正在分析您的问题...\n"
+        yield "🤔 Analyzing your question...\n"
 
-        yield "🔍 正在从工具库中推荐相关工具...\n"
+        yield "🔍 Recommending relevant tools from the library...\n"
         recommended_tools_meta = self.tool_recommender.recommend_tools(user_input)
 
         if not recommended_tools_meta:
-            yield "ℹ️ 未找到相关工具，将直接回答。\n"
-            recommended_tools_prompt = "没有推荐的工具。"
+            yield "ℹ️ No relevant tools found. Answering directly.\n"
+            recommended_tools_prompt = "No recommended tools."
         else:
             tool_names = [t["name"] for t in recommended_tools_meta]
-            yield f"✅ 推荐工具: `{', '.join(tool_names)}`\n"
+            yield f"✅ Recommended tools: `{', '.join(tool_names)}`\n"
             recommended_tools_prompt = self._format_tools_for_prompt(
                 recommended_tools_meta
             )
 
-        yield f"🧠 正在让AI大脑（{self.model_name}）决定如何行动...\n"
+        yield f"🧠 Letting the AI Brain ({self.model_name}) decide on the action...\n"
         prompt = AGENT_PROMPT_TEMPLATE.format(
             tools=recommended_tools_prompt,
             chat_history=self._format_chat_history(),
@@ -132,22 +126,19 @@ class SmartAIAgent:
         llm_response = self.llm.invoke(prompt)
         llm_decision_content = llm_response.content.strip()
 
-        # ------------------- 核心修复在这里！ -------------------
-        # 使用我们新的、更健壮的JSON提取逻辑
         decision = self._extract_json_from_string(llm_decision_content)
 
         if decision and "tool" in decision and "tool_input" in decision:
-            # 如果成功提取出有效的工具调用JSON
             tool_name = decision.get("tool")
             tool_input = decision.get("tool_input")
 
-            yield f"💡 AI决策：调用工具 `{tool_name}`，参数为 `{tool_input}`\n"
+            yield f"💡 AI Action: Call tool `{tool_name}` with parameters `{tool_input}`\n"
 
             tool_to_execute = get_tool_by_name(tool_name)
             if tool_to_execute:
-                yield f"⚙️ 正在执行工具 `{tool_name}`...\n"
+                yield f"⚙️ Executing tool `{tool_name}`...\n"
                 tool_output = tool_to_execute.invoke(tool_input)
-                yield f"📊 工具返回结果：\n---\n{str(tool_output)[:500]}...\n---\n"
+                yield f"📊 Tool Result:\n---\n{str(tool_output)[:500]}...\n---\n"
 
                 self.chat_history.append(
                     AIMessage(content=json.dumps(decision, ensure_ascii=False))
@@ -156,8 +147,8 @@ class SmartAIAgent:
                     ToolMessage(content=str(tool_output), tool_call_id="N/A")
                 )
 
-                yield "✍️ 正在根据工具结果生成最终回答...\n\n"
-                final_answer_prompt = f"基于以下对话历史和最新的工具结果，请为用户生成一个最终的、完整的、自然的回答。\n\n对话历史：\n{self._format_chat_history()}\n\n请直接回答，不要提及你的思考过程。"
+                yield "✍️ Generating final answer based on tool results...\n\n"
+                final_answer_prompt = f"Based on the conversation history and the latest tool result, generate a final, complete, and natural response for the user.\n\nConversation History:\n{self._format_chat_history()}\n\nPlease answer directly without mentioning your thought process."
                 final_answer_stream = self.llm.stream(final_answer_prompt)
                 full_final_answer = ""
                 for chunk in final_answer_stream:
@@ -165,10 +156,8 @@ class SmartAIAgent:
                     full_final_answer += chunk.content
                 self.chat_history.append(AIMessage(content=full_final_answer))
             else:
-                yield f"❌ 错误：AI决策调用的工具 `{tool_name}` 不存在。\n"
+                yield f"❌ Error: The tool `{tool_name}` decided by the AI does not exist.\n"
         else:
-            # 如果没有提取出JSON，或者JSON格式不正确，则认为是直接回答
-            yield "✅ AI决策：直接回答。\n\n"
+            yield "✅ AI Action: Answer directly.\n\n"
             yield llm_decision_content
             self.chat_history.append(AIMessage(content=llm_decision_content))
-        # ----------------------------------------------------

core/tool_recommender.py

@@ -6,27 +6,35 @@ from typing import List, Dict
 
 
 class DirectToolRecommender:
+    """
+    Directly uses Milvus and Google GenAI for tool recommendation.
+    No dependency on LlamaIndex.
+    """
+
     def __init__(self, milvus_client: MilvusClient, sqlite_db_path: str):
         self.milvus_client = milvus_client
         self.sqlite_db_path = sqlite_db_path
         self.collection_name = "tool_embeddings"
-
-        # ------------------- 核心修复在这里！ -------------------
-        # 使用你指定的、有额度的嵌入模型
         self.embedding_model_name = "gemini-embedding-exp-03-07"
-        # ----------------------------------------------------
 
         api_key = os.environ.get("GEMINI_API_KEY")
         if not api_key:
-            raise ValueError("错误：无法找到GEMINI_API_KEY。")
+            raise ValueError(
+                "Error: GEMINI_API_KEY not found. The recommender cannot function."
+            )
         genai.configure(api_key=api_key)
 
-        print(f"直接工具推荐器已初始化，使用嵌入模型: {self.embedding_model_name}。")
+        print(
+            f"Direct Tool Recommender initialized, using embedding model: {self.embedding_model_name}."
+        )
 
     def recommend_tools(self, user_query: str, top_k: int = 3) -> List[Dict]:
-        print(f"\n[推荐系统] 收到查询: '{user_query}'")
+        """
+        Recommends the top_k most relevant tools based on the user query.
+        """
+        print(f"\n[Tool Recommender] Received query: '{user_query}'")
 
-        # 1. 直接生成查询嵌入
+        # 1. Generate query embedding directly
         result = genai.embed_content(
             model=self.embedding_model_name,
             content=user_query,
@@ -34,7 +42,7 @@ class DirectToolRecommender:
         )
         query_embedding = result["embedding"]
 
-        # 2. 在Milvus中搜索
+        # 2. Search for similar tools in Milvus
         search_results = self.milvus_client.search(
             collection_name=self.collection_name,
             data=[query_embedding],
@@ -43,13 +51,13 @@ class DirectToolRecommender:
         )
 
         if not search_results or not search_results[0]:
-            print("[推荐系统] 在Milvus中未找到相似工具。")
+            print("[Tool Recommender] No similar tools found in Milvus.")
             return []
 
         recommended_ids = [hit["id"] for hit in search_results[0]]
-        print(f"[推荐系统] Milvus推荐的工具ID: {recommended_ids}")
+        print(f"[Tool Recommender] Milvus recommended tool IDs: {recommended_ids}")
 
-        # 3. 从SQLite中获取元数据并排序
+        # 3. Get full tool metadata from SQLite and sort
         with sqlite3.connect(self.sqlite_db_path) as conn:
             cursor = conn.cursor()
             if not recommended_ids:
@@ -71,5 +79,7 @@ class DirectToolRecommender:
             if tool_id in id_to_tool_meta
         ]
 
-        print(f"[推荐系统] 最终推荐的工具: {[t['name'] for t in sorted_tools]}")
+        print(
+            f"[Tool Recommender] Final recommended tools: {[t['name'] for t in sorted_tools]}"
+        )
         return sorted_tools

database/setup.py

@@ -6,46 +6,52 @@ import google.generativeai as genai
 
 from tools.tool_registry import get_all_tools
 
-# --- 配置持久化路径 ---
+# --- Configuration for persistence paths ---
 DATA_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "data"))
 SQLITE_DB_PATH = os.path.join(DATA_DIR, "tools.metadata.db")
 MILVUS_DATA_PATH = os.path.join(DATA_DIR, "milvus_lite.db")
 
-# --- 模型配置 ---
+# --- Model and DB Configuration ---
 EMBEDDING_DIM = 3072
 EMBEDDING_MODEL_NAME = "gemini-embedding-exp-03-07"
 MILVUS_COLLECTION_NAME = "tool_embeddings"
 
 
 def initialize_system():
-    print("--- 开始系统初始化 (最终通关版) ---")
+    """
+    The main system initialization function.
+    It creates directories, sets up the database and vector store, and loads tools.
+    This function is designed to be idempotent.
+    """
+    print("--- Starting System Initialization (Final Version) ---")
     os.makedirs(DATA_DIR, exist_ok=True)
 
-    # --- 正确的初始化顺序 ---
+    # --- Correct Initialization Order ---
 
-    # 1. 初始化SQLite并同步工具元数据
-    # 确保SQLite里总是有最新的工具信息
+    # 1. Initialize SQLite and sync tool metadata
+    # Ensures SQLite always has the latest tool information
     _init_sqlite_db()
     all_tools_definitions = get_all_tools()
     _sync_tools_to_sqlite(all_tools_definitions)
 
-    # 2. 初始化Milvus并同步向量
-    # 它会从已经填充好的SQLite中读取数据
+    # 2. Initialize Milvus and sync vector embeddings
+    # It reads data from the already populated SQLite DB
     milvus_client = _init_milvus_and_sync_embeddings()
 
-    # 3. 创建工具推荐器
+    # 3. Create the tool recommender instance
     from core.tool_recommender import DirectToolRecommender
 
     tool_recommender = DirectToolRecommender(
         milvus_client=milvus_client, sqlite_db_path=SQLITE_DB_PATH
     )
 
-    print("--- 系统初始化完成 ---")
+    print("--- System Initialization Complete ---")
     return all_tools_definitions, tool_recommender
 
 
 def _init_sqlite_db():
-    print(f"SQLite DB 路径: {SQLITE_DB_PATH}")
+    """Initializes the SQLite database and creates the tools table if it doesn't exist."""
+    print(f"SQLite DB Path: {SQLITE_DB_PATH}")
     with sqlite3.connect(SQLITE_DB_PATH) as conn:
         cursor = conn.cursor()
         cursor.execute(
@@ -59,11 +65,12 @@ def _init_sqlite_db():
         """
         )
         conn.commit()
-    print("SQLite DB 表已确认存在。")
+    print("SQLite DB table verified.")
 
 
 def _sync_tools_to_sqlite(tools_definitions):
-    print("正在同步工具元数据到SQLite...")
+    """Syncs tool definitions into the SQLite database."""
+    print("Syncing tool metadata to SQLite...")
     with sqlite3.connect(SQLITE_DB_PATH) as conn:
         cursor = conn.cursor()
         for tool in tools_definitions:
@@ -73,21 +80,24 @@ def _sync_tools_to_sqlite(tools_definitions):
                     "INSERT INTO tools (name, description, parameters) VALUES (?, ?, ?)",
                     (tool.name, tool.description, json.dumps(tool.args)),
                 )
-                print(f"  - 新增工具到SQLite: {tool.name}")
+                print(f"  - Added new tool to SQLite: {tool.name}")
         conn.commit()
-    print("SQLite同步完成。")
+    print("SQLite sync complete.")
 
 
 def _init_milvus_and_sync_embeddings():
-    print(f"Milvus Lite 数据路径: {MILVUS_DATA_PATH}")
+    """Initializes Milvus Lite, rebuilds the collection, and syncs embeddings."""
+    print(f"Milvus Lite Data Path: {MILVUS_DATA_PATH}")
     client = MilvusClient(uri=MILVUS_DATA_PATH)
 
-    # 每次启动都重新创建集合，确保维度正确且数据最新
+    # Recreate the collection on every startup to ensure correct dimensionality and fresh data for the demo.
     if client.has_collection(collection_name=MILVUS_COLLECTION_NAME):
         client.drop_collection(collection_name=MILVUS_COLLECTION_NAME)
-        print("发现旧的Milvus集合，已删除以重建。")
+        print("Found old Milvus collection. Dropped it to rebuild.")
 
-    print(f"Milvus集合 '{MILVUS_COLLECTION_NAME}' 正在创建，维度为 {EMBEDDING_DIM}...")
+    print(
+        f"Creating Milvus collection '{MILVUS_COLLECTION_NAME}' with dimension {EMBEDDING_DIM}..."
+    )
     fields = [
         FieldSchema(name="id", dtype=DataType.INT64, is_primary=True),
         FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=EMBEDDING_DIM),
@@ -102,9 +112,9 @@ def _init_milvus_and_sync_embeddings():
     client.create_index(
         collection_name=MILVUS_COLLECTION_NAME, index_params=index_params
     )
-    print("Milvus集合和索引创建完成。")
+    print("Milvus collection and index created successfully.")
 
-    # --- 关键：现在我们才同步嵌入 ---
+    # Critical Step: Now we sync the embeddings to the newly created collection
     _sync_tool_embeddings_to_milvus(client)
 
     client.load_collection(collection_name=MILVUS_COLLECTION_NAME)
@@ -112,10 +122,11 @@ def _init_milvus_and_sync_embeddings():
 
 
 def _sync_tool_embeddings_to_milvus(milvus_client):
-    print("正在同步工具嵌入到Milvus...")
+    """Generates and syncs tool description embeddings to Milvus Lite."""
+    print("Syncing tool embeddings to Milvus...")
     api_key = os.environ.get("GEMINI_API_KEY")
     if not api_key:
-        print("错误：无法找到GEMINI_API_KEY。")
+        print("Error: GEMINI_API_KEY not found.")
         return
     genai.configure(api_key=api_key)
 
@@ -125,13 +136,13 @@ def _sync_tool_embeddings_to_milvus(milvus_client):
         all_tools_in_db = cursor.fetchall()
 
     if not all_tools_in_db:
-        print("SQLite中没有工具可同步，这是一个错误！")
+        print("Error: No tools found in SQLite to sync.")
         return
 
-    print(f"从SQLite发现 {len(all_tools_in_db)} 个工具，正在生成嵌入...")
+    print(f"Found {len(all_tools_in_db)} tools from SQLite, generating embeddings...")
     docs_to_embed = [tool[1] for tool in all_tools_in_db]
 
-    print(f"使用嵌入模型: {EMBEDDING_MODEL_NAME}")
+    print(f"Using embedding model: {EMBEDDING_MODEL_NAME}")
     result = genai.embed_content(
         model=EMBEDDING_MODEL_NAME,
         content=docs_to_embed,
@@ -147,4 +158,4 @@ def _sync_tool_embeddings_to_milvus(milvus_client):
     ]
 
     milvus_client.insert(collection_name=MILVUS_COLLECTION_NAME, data=data_to_insert)
-    print(f"成功将 {len(data_to_insert)} 个新嵌入插入到Milvus。")
+    print(f"Successfully inserted {len(data_to_insert)} new embeddings into Milvus.")

tools/news_tool.py

@@ -6,9 +6,9 @@ from bs4 import BeautifulSoup
 
 def search_latest_news(query: str) -> str:
     """
-    使用requests和BeautifulSoup抓取DuckDuckGo搜索结果来模拟新闻搜索。
+    Simulates a news search by scraping DuckDuckGo search results using requests and BeautifulSoup.
     """
-    print(f"--- 正在执行工具: search_latest_news, 参数: {query} ---")
+    print(f"--- Executing Tool: search_latest_news, Parameters: {query} ---")
     headers = {
         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
     }
@@ -22,9 +22,9 @@ def search_latest_news(query: str) -> str:
         results = soup.find_all("div", class_="result")
 
         if not results:
-            return "没有找到相关的新闻报道。"
+            return "No relevant news articles were found."
 
-        # 提取前三个结果的摘要
+        # Extract snippets from the top 3 results
         snippets = []
         for result in results[:3]:
             title_tag = result.find("a", class_="result__a")
@@ -32,11 +32,11 @@ def search_latest_news(query: str) -> str:
             if title_tag and snippet_tag:
                 title = title_tag.text.strip()
                 snippet = snippet_tag.text.strip()
-                snippets.append(f"标题: {title}\n摘要: {snippet}\n")
+                snippets.append(f"Title: {title}\nSnippet: {snippet}\n")
 
         return "\n---\n".join(snippets)
 
     except requests.RequestException as e:
-        return f"搜索新闻时发生网络错误: {e}"
+        return f"A network error occurred while searching for news: {e}"
     except Exception as e:
-        return f"解析新闻搜索结果时发生错误: {e}"
+        return f"An error occurred while parsing news search results: {e}"

tools/stock_tool.py

@@ -6,18 +6,18 @@ import random
 
 def get_stock_price(symbol: str) -> str:
     """
-    模拟获取股票价格的函数。
-    在真实世界中，这里会调用一个真正的金融API。
+    Simulates fetching a stock price.
+    In a real-world scenario, this would call a proper financial API.
     """
-    print(f"--- 正在执行工具: get_stock_price, 参数: {symbol} ---")
+    print(f"--- Executing Tool: get_stock_price, Parameters: {symbol} ---")
     symbol = symbol.upper()
-    # 模拟API调用
+    # Simulate an API call
     try:
-        # 这是一个模拟，实际应该调用如Alpha Vantage, Yahoo Finance等API
+        # This is a simulation. A real implementation would use an API like Alpha Vantage, Yahoo Finance, etc.
         if symbol in ["AAPL", "GOOGL", "MSFT"]:
             price = round(random.uniform(100, 500), 2)
-            return f"股票 {symbol} 的模拟实时价格是 ${price}。"
+            return f"The simulated real-time price for stock {symbol} is ${price}."
         else:
-            return f"找不到股票代码为 {symbol} 的信息。"
+            return f"Could not find information for stock symbol: {symbol}."
     except Exception as e:
-        return f"调用股票API时发生错误: {e}"
+        return f"An error occurred while calling the stock API: {e}"

tools/tool_registry.py

@@ -1,22 +1,21 @@
 # tools/tool_registry.py
 
 from langchain_core.tools import tool
-from typing import List, Dict, Any
+from typing import List, Any
 
-# 导入你的实际工具函数
+# Import the actual tool functions
 from .stock_tool import get_stock_price
 from .news_tool import search_latest_news
 
-# 使用LangChain的@tool装饰器来定义工具，它会自动处理描述和参数结构
-# 这比手动构建字典更健壮
+# Use LangChain's @tool decorator to define tools.
+# This is more robust as it automatically handles descriptions and argument schemas.
 
 
-# 使用 @tool 装饰器定义你的工具
 @tool
 def get_stock_price_tool(symbol: str) -> str:
     """
-    获取指定股票代码（例如AAPL, GOOGL）的实时股票价格。
-    当用户询问特定公司的股价时使用此工具。
+    Gets the real-time stock price for a given stock symbol (e.g., AAPL, GOOGL).
+    Use this tool when the user asks for the stock price of a specific company.
     """
     return get_stock_price(symbol)
 
@@ -24,13 +23,13 @@ def get_stock_price_tool(symbol: str) -> str:
 @tool
 def search_latest_news_tool(query: str) -> str:
     """
-    根据关键词搜索最新的新闻报道。
-    当用户询问关于某个主题的最新动态、事件或新闻时使用此工具。
+    Searches for the latest news articles based on a keyword.
+    Use this tool when the user asks about the latest updates, events, or news on a certain topic.
     """
     return search_latest_news(query)
 
 
-# 集中管理所有工具
+# Central registry for all tools
 _all_tools = [
     get_stock_price_tool,
     search_latest_news_tool,
@@ -38,12 +37,12 @@ _all_tools = [
 
 
 def get_all_tools() -> List[Any]:
-    """返回一个包含所有已定义工具的列表。"""
+    """Returns a list containing all defined tool objects."""
     return _all_tools
 
 
 def get_tool_by_name(name: str) -> Any:
-    """根据名称查找并返回工具对象。"""
+    """Finds and returns a tool object by its name."""
     for tool_obj in _all_tools:
         if tool_obj.name == name:
             return tool_obj