feat(multimodel): support multimodal memory display and improve code style

api/app/core/memory/agent/langgraph_graph/nodes/data_nodes.py

@@ -4,13 +4,13 @@ from app.core.memory.agent.utils.llm_tools import ReadState, WriteState
 def content_input_node(state: ReadState) -> ReadState:
     """
     Start node - Extract content and maintain state information
-    
+
     Extracts the content from the first message in the state and returns it
     as the data field while preserving all other state information.
-    
+
     Args:
         state: ReadState containing messages and other state data
-        
+
     Returns:
         ReadState: Updated state with extracted content in data field
     """
@@ -19,19 +19,20 @@ def content_input_node(state: ReadState) -> ReadState:
     # Return content and maintain all state information
     return {"data": content}
 
+
 def content_input_write(state: WriteState) -> WriteState:
     """
     Start node - Extract content and maintain state information for write operations
-    
+
     Extracts the content from the first message in the state for write operations.
-    
+
     Args:
         state: WriteState containing messages and other state data
-        
+
     Returns:
         WriteState: Updated state with extracted content in data field
     """
 
     content = state['messages'][0].content if state.get('messages') else ''
     # Return content and maintain all state information
-    return {"data": content}
+    return {"data": content}

api/app/core/memory/agent/langgraph_graph/routing/routers.py

@@ -1,13 +1,13 @@
-
 from typing import Literal
 
 from app.core.logging_config import get_agent_logger
 from app.core.memory.agent.utils.llm_tools import ReadState, COUNTState
 
-
 logger = get_agent_logger(__name__)
 counter = COUNTState(limit=3)
-def Split_continue(state:ReadState) -> Literal["Split_The_Problem", "Input_Summary"]:
+
+
+def Split_continue(state: ReadState) -> Literal["Split_The_Problem", "Input_Summary"]:
     """
     Determine routing based on search_switch value.
 
@@ -25,6 +25,7 @@ def Split_continue(state:ReadState) -> Literal["Split_The_Problem", "Input_Summa
             return 'Input_Summary'
     return 'Split_The_Problem'  # 默认情况
 
+
 def Retrieve_continue(state) -> Literal["Verify", "Retrieve_Summary"]:
     """
     Determine routing based on search_switch value.
@@ -43,8 +44,10 @@ def Retrieve_continue(state) -> Literal["Verify", "Retrieve_Summary"]:
         elif search_switch == '1':
             return 'Retrieve_Summary'
     return 'Retrieve_Summary'  # Default based on business logic
+
+
 def Verify_continue(state: ReadState) -> Literal["Summary", "Summary_fails", "content_input"]:
-    status=state.get('verify', '')['status']
+    status = state.get('verify', '')['status']
     # loop_count = counter.get_total()
     if "success" in status:
         # counter.reset()
@@ -53,7 +56,7 @@ def Verify_continue(state: ReadState) -> Literal["Summary", "Summary_fails", "co
         # if loop_count < 2:  # Maximum loop count is 3
         #     return "content_input"
         # else:
-            # counter.reset()
+        # counter.reset()
         return "Summary_fails"
     else:
         # Add default return value to avoid returning None

api/app/core/memory/agent/langgraph_graph/routing/write_router.py

@@ -2,32 +2,32 @@ import json
 import os
 
 from app.core.logging_config import get_agent_logger
-from app.core.memory.agent.langgraph_graph.tools.write_tool import  format_parsing,  messages_parse
-from app.core.memory.agent.langgraph_graph.write_graph import make_write_graph, long_term_storage
-
+from app.core.memory.agent.langgraph_graph.tools.write_tool import format_parsing, messages_parse
 from app.core.memory.agent.models.write_aggregate_model import WriteAggregateModel
 from app.core.memory.agent.utils.llm_tools import PROJECT_ROOT_
-from app.core.memory.agent.utils.redis_tool import write_store
 from app.core.memory.agent.utils.redis_tool import count_store
+from app.core.memory.agent.utils.redis_tool import write_store
 from app.core.memory.agent.utils.template_tools import TemplateService
 from app.core.memory.utils.llm.llm_utils import MemoryClientFactory
-from app.db import get_db_context, get_db
+from app.db import get_db_context
 from app.repositories.memory_short_repository import LongTermMemoryRepository
 from app.schemas.memory_agent_schema import AgentMemory_Long_Term
 from app.services.memory_konwledges_server import write_rag
 from app.services.task_service import get_task_memory_write_result
 from app.tasks import write_message_task
 from app.utils.config_utils import resolve_config_id
+
 logger = get_agent_logger(__name__)
 template_root = os.path.join(PROJECT_ROOT_, 'memory', 'agent', 'utils', 'prompt')
 
+
 async def write_rag_agent(end_user_id, user_message, ai_message, user_rag_memory_id):
     """
     Write messages to RAG storage system
-    
+
     Combines user and AI messages into a single string format and stores them
     in the RAG (Retrieval-Augmented Generation) knowledge base for future retrieval.
-    
+
     Args:
         end_user_id: User identifier for the conversation
         user_message: User's input message content
@@ -38,14 +38,24 @@ async def write_rag_agent(end_user_id, user_message, ai_message, user_rag_memory
     combined_message = f"user: {user_message}\nassistant: {ai_message}"
     await write_rag(end_user_id, combined_message, user_rag_memory_id)
     logger.info(f'RAG_Agent:{end_user_id};{user_rag_memory_id}')
-async def write(storage_type, end_user_id, user_message, ai_message, user_rag_memory_id, actual_end_user_id,
-                actual_config_id, long_term_messages=[]):
+
+
+async def write(
+        storage_type,
+        end_user_id,
+        user_message,
+        ai_message,
+        user_rag_memory_id,
+        actual_end_user_id,
+        actual_config_id,
+        long_term_messages=None
+):
     """
     Write memory with structured message support
-    
+
     Handles memory writing operations for different storage types (Neo4j/RAG).
     Supports both individual message pairs and batch long-term message processing.
-    
+
     Args:
         storage_type: Storage type identifier ("neo4j" or "rag")
         end_user_id: Terminal user identifier
@@ -55,7 +65,7 @@ async def write(storage_type, end_user_id, user_message, ai_message, user_rag_me
         actual_end_user_id: Actual user identifier for storage
         actual_config_id: Configuration identifier
         long_term_messages: Optional list of structured messages for batch processing
-        
+
     Logic explanation:
     - RAG mode: Combines user_message and ai_message into string format, maintains original logic
     - Neo4j mode: Uses structured message lists
@@ -64,8 +74,9 @@ async def write(storage_type, end_user_id, user_message, ai_message, user_rag_me
       3. Each message is converted to independent Chunk, preserving speaker field
     """
 
-    db = next(get_db())
-    try:
+    if long_term_messages is None:
+        long_term_messages = []
+    with get_db_context() as db:
         actual_config_id = resolve_config_id(actual_config_id, db)
         # Neo4j mode: Use structured message lists
         structured_messages = []
@@ -105,17 +116,16 @@ async def write(storage_type, end_user_id, user_message, ai_message, user_rag_me
         logger.info(f"[WRITE] Celery task submitted - task_id={write_id}")
         write_status = get_task_memory_write_result(str(write_id))
         logger.info(f'[WRITE] Task result - user={actual_end_user_id}, status={write_status}')
-    finally:
-        db.close()
 
-async def term_memory_save(long_term_messages,actual_config_id,end_user_id,type,scope):
+
+async def term_memory_save(long_term_messages, actual_config_id, end_user_id, type, scope):
     """
     Save long-term memory data to database
-    
+
     Handles the storage of long-term memory data based on different strategies
     (chunk-based or aggregate-based) and manages the transition from short-term
     to long-term memory storage.
-    
+
     Args:
         long_term_messages: Long-term message data to be saved
         actual_config_id: Configuration identifier for memory settings
@@ -126,13 +136,12 @@ async def term_memory_save(long_term_messages,actual_config_id,end_user_id,type,
     with get_db_context() as db_session:
         repo = LongTermMemoryRepository(db_session)
 
-
         from app.core.memory.agent.utils.redis_tool import write_store
         result = write_store.get_session_by_userid(end_user_id)
-        if type==AgentMemory_Long_Term.STRATEGY_CHUNK or AgentMemory_Long_Term.STRATEGY_AGGREGATE:
+        if type == AgentMemory_Long_Term.STRATEGY_CHUNK or AgentMemory_Long_Term.STRATEGY_AGGREGATE:
             data = await format_parsing(result, "dict")
             chunk_data = data[:scope]
-            if len(chunk_data)==scope:
+            if len(chunk_data) == scope:
                 repo.upsert(end_user_id, chunk_data)
                 logger.info(f'---------写入短长期-----------')
         else:
@@ -142,22 +151,23 @@ async def term_memory_save(long_term_messages,actual_config_id,end_user_id,type,
             logger.info(f'写入短长期：')
 
 
-
 """Window-based dialogue processing"""
-async def window_dialogue(end_user_id,langchain_messages,memory_config,scope):
+
+
+async def window_dialogue(end_user_id, langchain_messages, memory_config, scope):
     """
     Process dialogue based on window size and write to Neo4j
-    
+
     Manages conversation data based on a sliding window approach. When the window
     reaches the specified scope size, it triggers long-term memory storage to Neo4j.
-    
+
     Args:
         end_user_id: Terminal user identifier
         memory_config: Memory configuration object containing settings
         langchain_messages: Original message data list
         scope: Window size determining when to trigger long-term storage
     """
-    scope=scope
+    scope = scope
     is_end_user_id = count_store.get_sessions_count(end_user_id)
     if is_end_user_id is not False:
         is_end_user_id = count_store.get_sessions_count(end_user_id)[0]
@@ -174,42 +184,53 @@ async def window_dialogue(end_user_id,langchain_messages,memory_config,scope):
             config_id = memory_config.config_id
         else:
             config_id = memory_config
-        
-        await write(AgentMemory_Long_Term.STORAGE_NEO4J, end_user_id, "", "", None, end_user_id,
-                config_id, formatted_messages)
+
+        await write(
+            AgentMemory_Long_Term.STORAGE_NEO4J,
+            end_user_id,
+            "",
+            "",
+            None,
+            end_user_id,
+            config_id,
+            formatted_messages
+        )
         count_store.update_sessions_count(end_user_id, 1, langchain_messages)
     else:
         count_store.save_sessions_count(end_user_id, 1, langchain_messages)
 
 
 """Time-based memory processing"""
-async def memory_long_term_storage(end_user_id,memory_config,time):
+
+
+async def memory_long_term_storage(end_user_id, memory_config, time):
     """
     Process memory storage based on time intervals and write to Neo4j
-    
+
     Retrieves Redis data based on time intervals and writes it to Neo4j for
     long-term storage. This function handles time-based memory consolidation.
-    
+
     Args:
         end_user_id: Terminal user identifier
         memory_config: Memory configuration object containing settings
         time: Time interval for data retrieval
     """
     long_time_data = write_store.find_user_recent_sessions(end_user_id, time)
-    format_messages = (long_time_data)
-    messages=[]
-    memory_config=memory_config.config_id
+    format_messages = long_time_data
+    messages = []
+    memory_config = memory_config.config_id
     for i in format_messages:
-        message=json.loads(i['Query'])
-        messages+= message
-    if format_messages!=[]:
+        message = json.loads(i['Query'])
+        messages += message
+    if format_messages:
         await write(AgentMemory_Long_Term.STORAGE_NEO4J, end_user_id, "", "", None, end_user_id,
                     memory_config, messages)
-"""Aggregation judgment processing"""
+
+
 async def aggregate_judgment(end_user_id: str, ori_messages: list, memory_config) -> dict:
     """
     Aggregation judgment function: determine if input sentence and historical messages describe the same event
-    
+
     Uses LLM-based analysis to determine whether new messages should be aggregated with existing
     historical data or stored as separate events. This helps optimize memory storage and retrieval.
     
@@ -217,11 +238,11 @@ async def aggregate_judgment(end_user_id: str, ori_messages: list, memory_config
         end_user_id: Terminal user identifier
         ori_messages: Original message list, format like [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]
         memory_config: Memory configuration object containing LLM settings
-        
+
     Returns:
         dict: Aggregation judgment result containing is_same_event flag and processed output
     """
-
+    history = None
     try:
         # 1. Get historical session data (using new method)
         result = write_store.get_all_sessions_by_end_user_id(end_user_id)
@@ -255,7 +276,7 @@ async def aggregate_judgment(end_user_id: str, ori_messages: list, memory_config
         output_value = structured.output
         if isinstance(output_value, list):
             output_value = [
-                {"role": msg.role, "content": msg.content} 
+                {"role": msg.role, "content": msg.content}
                 for msg in output_value
             ]
 
@@ -268,16 +289,16 @@ async def aggregate_judgment(end_user_id: str, ori_messages: list, memory_config
             await write("neo4j", end_user_id, "", "", None, end_user_id,
                         memory_config.config_id, output_value)
         return result_dict
-        
+
     except Exception as e:
         print(f"[aggregate_judgment] 发生错误: {e}")
         import traceback
         traceback.print_exc()
-        
+
         return {
             "is_same_event": False,
             "output": ori_messages,
             "messages": ori_messages,
             "history": history if 'history' in locals() else [],
             "error": str(e)
-        }
+        }

api/app/core/memory/agent/langgraph_graph/tools/tool.py

@@ -2,26 +2,25 @@ import asyncio
 import json
 from datetime import datetime, timedelta
 
-
 from langchain.tools import tool
 from pydantic import BaseModel, Field
 
-
 from app.core.memory.src.search import (
     search_by_temporal,
     search_by_keyword_temporal,
 )
 
+
 def extract_tool_message_content(response):
     """
     Extract ToolMessage content and tool names from agent response
-    
+
     Parses agent response messages to extract tool execution results and metadata.
     Handles JSON parsing and provides structured access to tool output data.
-    
+
     Args:
         response: Agent response dictionary containing messages
-        
+
     Returns:
         dict: Dictionary containing tool_name and parsed content, or None if no tool message found
             - tool_name: Name of the executed tool
@@ -61,10 +60,10 @@ def extract_tool_message_content(response):
 class TimeRetrievalInput(BaseModel):
     """
     Input schema for time retrieval tool
-    
+
     Defines the expected input parameters for time-based retrieval operations.
     Used for validation and documentation of tool parameters.
-    
+
     Attributes:
         context: User input query content for search
         end_user_id: Group ID for filtering search results, defaults to test user
@@ -72,25 +71,26 @@ class TimeRetrievalInput(BaseModel):
     context: str = Field(description="用户输入的查询内容")
     end_user_id: str = Field(default="88a459f5_text09", description="组ID，用于过滤搜索结果")
 
+
 def create_time_retrieval_tool(end_user_id: str):
     """
     Create a TimeRetrieval tool with specific end_user_id (synchronous version) for searching statements by time range
-    
+
     Creates a specialized time-based retrieval tool that searches for statements within
     specified time ranges. Includes field cleaning functionality to remove unnecessary
     metadata from search results.
-    
+
     Args:
         end_user_id: User identifier for scoping search results
-        
+
     Returns:
         function: Configured TimeRetrievalWithGroupId tool function
     """
-    
+
     def clean_temporal_result_fields(data):
         """
         Clean unnecessary fields from temporal search results and modify structure
-        
+
         Removes metadata fields that are not needed for end-user consumption and
         restructures the response format for better usability.
         
@@ -102,10 +102,10 @@ def create_time_retrieval_tool(end_user_id: str):
         """
         # List of fields to filter out
         fields_to_remove = {
-            'id', 'apply_id', 'user_id', 'chunk_id', 'created_at', 
+            'id', 'apply_id', 'user_id', 'chunk_id', 'created_at',
             'valid_at', 'invalid_at', 'statement_ids'
         }
-        
+
         if isinstance(data, dict):
             cleaned = {}
             for key, value in data.items():
@@ -126,15 +126,16 @@ def create_time_retrieval_tool(end_user_id: str):
             return [clean_temporal_result_fields(item) for item in data]
         else:
             return data
-    
+
     @tool
-    def TimeRetrievalWithGroupId(context: str, start_date: str = None, end_date: str = None, end_user_id_param: str = None, clean_output: bool = True) -> str:
+    def TimeRetrievalWithGroupId(context: str, start_date: str = None, end_date: str = None,
+                                 end_user_id_param: str = None, clean_output: bool = True) -> str:
         """
         Optimized time retrieval tool, combines time range search only (synchronous version), automatically filters unnecessary metadata fields
-        
+
         Performs time-based search operations with automatic metadata filtering. Supports
         flexible date range specification and provides clean, user-friendly output.
-        
+
         Explicit parameters:
         - context: Query context content
         - start_date: Start time (optional, format: YYYY-MM-DD)
@@ -142,10 +143,11 @@ def create_time_retrieval_tool(end_user_id: str):
         - end_user_id_param: Group ID (optional, overrides default group ID)
         - clean_output: Whether to clean metadata fields from output
         - end_date needs to be obtained based on user description, output format uses strftime("%Y-%m-%d")
-        
+
         Returns:
             str: JSON formatted search results with temporal data
         """
+
         async def _async_search():
             # Use passed parameters or default values
             actual_end_user_id = end_user_id_param or end_user_id
@@ -167,18 +169,19 @@ def create_time_retrieval_tool(end_user_id: str):
                 cleaned_results = results
 
             return json.dumps(cleaned_results, ensure_ascii=False, indent=2)
-        
+
         return asyncio.run(_async_search())
 
     @tool
-    def KeywordTimeRetrieval(context: str, days_back: int = 7, start_date: str = None, end_date: str = None, clean_output: bool = True) -> str:
+    def KeywordTimeRetrieval(context: str, days_back: int = 7, start_date: str = None, end_date: str = None,
+                             clean_output: bool = True) -> str:
         """
         Optimized keyword time retrieval tool, combines keyword and time range search (synchronous version), automatically filters unnecessary metadata fields
-        
+
         Performs combined keyword and temporal search operations with automatic metadata
         filtering. Provides more targeted search results by combining content relevance
         with time-based filtering.
-        
+
         Explicit parameters:
         - context: Query content for keyword matching
         - days_back: Number of days to search backwards, default 7 days
@@ -186,10 +189,11 @@ def create_time_retrieval_tool(end_user_id: str):
         - end_date: End time (optional, format: YYYY-MM-DD)
         - clean_output: Whether to clean metadata fields from output
         - end_date needs to be obtained based on user description, output format uses strftime("%Y-%m-%d")
-        
+
         Returns:
             str: JSON formatted search results combining keyword and temporal data
         """
+
         async def _async_search():
             actual_end_date = end_date or datetime.now().strftime("%Y-%m-%d")
             actual_start_date = start_date or (datetime.now() - timedelta(days=days_back)).strftime("%Y-%m-%d")
@@ -212,29 +216,29 @@ def create_time_retrieval_tool(end_user_id: str):
             return json.dumps(cleaned_results, ensure_ascii=False, indent=2)
 
         return asyncio.run(_async_search())
-    
+
     return TimeRetrievalWithGroupId
 
 
 def create_hybrid_retrieval_tool_async(memory_config, **search_params):
     """
     Create hybrid retrieval tool using run_hybrid_search for hybrid retrieval, optimize output format and filter unnecessary fields
-    
+
     Creates an advanced hybrid search tool that combines multiple search strategies
     (keyword, vector, hybrid) with automatic result cleaning and formatting.
     
     Args:
         memory_config: Memory configuration object containing LLM and search settings
         **search_params: Search parameters including end_user_id, limit, include, etc.
-        
+
     Returns:
         function: Configured HybridSearch tool function with async capabilities
     """
-    
+
     def clean_result_fields(data):
         """
         Recursively clean unnecessary fields from results
-        
+
         Removes metadata fields that are not needed for end-user consumption,
         improving readability and reducing response size.
         
@@ -247,11 +251,11 @@ def create_hybrid_retrieval_tool_async(memory_config, **search_params):
         # List of fields to filter out
         # TODO: fact_summary functionality temporarily disabled, will be enabled after future development
         fields_to_remove = {
-            'invalid_at', 'valid_at', 'chunk_id_from_rel', 'entity_ids', 
-            'expired_at', 'created_at', 'chunk_id', 'id', 'apply_id', 
-            'user_id', 'statement_ids', 'updated_at',"chunk_ids"  ,"fact_summary"
+            'invalid_at', 'valid_at', 'chunk_id_from_rel', 'entity_ids',
+            'expired_at', 'created_at', 'chunk_id', 'id', 'apply_id',
+            'user_id', 'statement_ids', 'updated_at', "chunk_ids", "fact_summary"
         }
-        
+
         if isinstance(data, dict):
             # Clean dictionary
             cleaned = {}
@@ -265,7 +269,7 @@ def create_hybrid_retrieval_tool_async(memory_config, **search_params):
         else:
             # Return other types directly
             return data
-    
+
     @tool
     async def HybridSearch(
         context: str, 
@@ -279,7 +283,7 @@ def create_hybrid_retrieval_tool_async(memory_config, **search_params):
     ) -> str:
         """
         Optimized hybrid retrieval tool, supports keyword, vector and hybrid search, automatically filters unnecessary metadata fields
-        
+
         Provides comprehensive search capabilities combining multiple search strategies
         with intelligent result ranking and automatic metadata filtering for clean output.
         
@@ -292,7 +296,7 @@ def create_hybrid_retrieval_tool_async(memory_config, **search_params):
             use_forgetting_rerank: Whether to use forgetting-based reranking
             use_llm_rerank: Whether to use LLM-based reranking
             clean_output: Whether to clean metadata fields from output
-            
+
         Returns:
             str: JSON formatted comprehensive search results
         """
@@ -329,9 +333,9 @@ def create_hybrid_retrieval_tool_async(memory_config, **search_params):
                 "search_type": search_type,
                 "results": cleaned_results
             }
-            
+
             return json.dumps(formatted_results, ensure_ascii=False, indent=2, default=str)
-            
+
         except Exception as e:
             error_result = {
                 "error": f"混合检索失败: {str(e)}",
@@ -340,35 +344,36 @@ def create_hybrid_retrieval_tool_async(memory_config, **search_params):
                 "timestamp": datetime.now().isoformat()
             }
             return json.dumps(error_result, ensure_ascii=False, indent=2)
-    
+
     return HybridSearch
 
 
 def create_hybrid_retrieval_tool_sync(memory_config, **search_params):
     """
     Create synchronous version of hybrid retrieval tool, optimize output format and filter unnecessary fields
-    
+
     Creates a synchronous wrapper around the async hybrid search functionality,
     making it compatible with synchronous tool execution environments.
     
     Args:
         memory_config: Memory configuration object containing search settings
         **search_params: Search parameters for configuration
-        
+
     Returns:
         function: Configured HybridSearchSync tool function
     """
+
     @tool
     def HybridSearchSync(
-        context: str, 
-        search_type: str = "hybrid",
-        limit: int = 10,
-        end_user_id: str = None,
-        clean_output: bool = True
+            context: str,
+            search_type: str = "hybrid",
+            limit: int = 10,
+            end_user_id: str = None,
+            clean_output: bool = True
     ) -> str:
         """
         Optimized hybrid retrieval tool (synchronous version), automatically filters unnecessary metadata fields
-        
+
         Provides the same hybrid search capabilities as the async version but in a
         synchronous execution context. Automatically handles async-to-sync conversion.
         
@@ -378,10 +383,11 @@ def create_hybrid_retrieval_tool_sync(memory_config, **search_params):
             limit: Result quantity limit
             end_user_id: Group ID for filtering search results
             clean_output: Whether to clean metadata fields from output
-            
+
         Returns:
             str: JSON formatted search results
         """
+
         async def _async_search():
             # Create async tool and execute
             async_tool = create_hybrid_retrieval_tool_async(memory_config, **search_params)
@@ -392,7 +398,7 @@ def create_hybrid_retrieval_tool_sync(memory_config, **search_params):
                 "end_user_id": end_user_id,
                 "clean_output": clean_output
             })
-        
+
         return asyncio.run(_async_search())
-    
-    return HybridSearchSync
+
+    return HybridSearchSync

api/app/core/memory/agent/langgraph_graph/tools/write_tool.py

@@ -1,10 +1,12 @@
 import json
 
 from langchain_core.messages import HumanMessage, AIMessage
-async def format_parsing(messages: list,type:str='string'):
+
+
+async def format_parsing(messages: list, type: str = 'string'):
     """
     Format and parse message lists into different output types
-    
+
     Processes message lists from storage and converts them into either string format
     or dictionary format based on the specified type parameter. Handles JSON parsing
     and role-based message organization.
@@ -19,8 +21,8 @@ async def format_parsing(messages: list,type:str='string'):
             - 'dict': List of dictionaries mapping user messages to AI responses
     """
     result = []
-    user=[]
-    ai=[]
+    user = []
+    ai = []
 
     for message in messages:
         hstory_messages = message['messages']
@@ -30,37 +32,38 @@ async def format_parsing(messages: list,type:str='string'):
                 role = content['role']
                 content = content['content']
                 if type == "string":
-                    if role == 'human' or role=="user":
+                    if role == 'human' or role == "user":
                         content = '用户:' + content
                     else:
                         content = 'AI:' + content
                     result.append(content)
-                if type == "dict" :
-                    if role == 'human'  or role=="user":
-                        user.append( content)
+                if type == "dict":
+                    if role == 'human' or role == "user":
+                        user.append(content)
                     else:
                         ai.append(content)
     if type == "dict":
-        for key,values in zip(user,ai):
-            result.append({key:values})
+        for key, values in zip(user, ai):
+            result.append({key: values})
     return result
 
+
 async def messages_parse(messages: list | dict):
     """
     Parse messages from storage format into user-AI conversation pairs
-    
+
     Extracts and organizes conversation data from stored message format,
     separating user and AI messages and pairing them for database storage.
-    
+
     Args:
         messages: List or dictionary containing stored message data with Query fields
-        
+
     Returns:
         list: List of dictionaries containing user-AI message pairs for database storage
     """
-    user=[]
-    ai=[]
-    database=[]
+    user = []
+    ai = []
+    database = []
     for message in messages:
         Query = message['Query']
         Query = json.loads(Query)
@@ -72,20 +75,20 @@ async def messages_parse(messages: list | dict):
                 ai.append(data['content'])
     for key, values in zip(user, ai):
         database.append({key, values})
-    return  database
+    return database
 
 
-async def agent_chat_messages(user_content,ai_content):
+async def agent_chat_messages(user_content, ai_content):
     """
     Create structured chat message format for agent conversations
-    
+
     Formats user and AI content into a standardized message structure suitable
     for agent processing and storage. Creates role-based message objects.
-    
+
     Args:
         user_content: User's message content string
         ai_content: AI's response content string
-        
+
     Returns:
         list: List of structured message dictionaries with role and content fields
     """

api/app/core/memory/agent/langgraph_graph/write_graph.py

@@ -13,7 +13,6 @@ from app.core.memory.agent.langgraph_graph.nodes.write_nodes import write_node
 from app.schemas.memory_agent_schema import AgentMemory_Long_Term
 from app.services.memory_config_service import MemoryConfigService
 
-
 warnings.filterwarnings("ignore", category=RuntimeWarning)
 logger = get_agent_logger(__name__)
 
@@ -42,13 +41,15 @@ async def make_write_graph():
 
     yield graph
 
-async def long_term_storage(long_term_type:str="chunk",langchain_messages:list=[],memory_config:str='',end_user_id:str='',scope:int=6):
+
+async def long_term_storage(long_term_type: str = "chunk", langchain_messages: list = [], memory_config: str = '',
+                            end_user_id: str = '', scope: int = 6):
     """
     Handle long-term memory storage with different strategies
-    
-    Supports multiple storage strategies including chunk-based, time-based, 
+
+    Supports multiple storage strategies including chunk-based, time-based,
     and aggregate judgment approaches for long-term memory persistence.
-    
+
     Args:
         long_term_type: Storage strategy type ('chunk', 'time', 'aggregate')
         langchain_messages: List of messages to store
@@ -56,9 +57,10 @@ async def long_term_storage(long_term_type:str="chunk",langchain_messages:list=[
         end_user_id: User group identifier
         scope: Scope parameter for chunk-based storage (default: 6)
     """
-    from app.core.memory.agent.langgraph_graph.routing.write_router import memory_long_term_storage, window_dialogue,aggregate_judgment
+    from app.core.memory.agent.langgraph_graph.routing.write_router import memory_long_term_storage, window_dialogue, \
+        aggregate_judgment
     from app.core.memory.agent.utils.redis_tool import write_store
-    write_store.save_session_write(end_user_id,  (langchain_messages))
+    write_store.save_session_write(end_user_id, langchain_messages)
     # 获取数据库会话
     with get_db_context() as db_session:
         config_service = MemoryConfigService(db_session)
@@ -66,25 +68,24 @@ async def long_term_storage(long_term_type:str="chunk",langchain_messages:list=[
             config_id=memory_config,  # 改为整数
             service_name="MemoryAgentService"
         )
-        if long_term_type==AgentMemory_Long_Term.STRATEGY_CHUNK:
+        if long_term_type == AgentMemory_Long_Term.STRATEGY_CHUNK:
             '''Strategy 1: Dialogue window with 6 rounds of conversation'''
-            await window_dialogue(end_user_id,langchain_messages,memory_config,scope)
-        if long_term_type==AgentMemory_Long_Term.STRATEGY_TIME:
+            await window_dialogue(end_user_id, langchain_messages, memory_config, scope)
+        if long_term_type == AgentMemory_Long_Term.STRATEGY_TIME:
             """Time-based strategy"""
-            await memory_long_term_storage(end_user_id, memory_config,AgentMemory_Long_Term.TIME_SCOPE)
-        if  long_term_type==AgentMemory_Long_Term.STRATEGY_AGGREGATE:
+            await memory_long_term_storage(end_user_id, memory_config, AgentMemory_Long_Term.TIME_SCOPE)
+        if long_term_type == AgentMemory_Long_Term.STRATEGY_AGGREGATE:
             """Strategy 3: Aggregate judgment"""
             await aggregate_judgment(end_user_id, langchain_messages, memory_config)
 
 
-
-async def write_long_term(storage_type,end_user_id,message_chat,aimessages,user_rag_memory_id,actual_config_id):
+async def write_long_term(storage_type, end_user_id, message_chat, aimessages, user_rag_memory_id, actual_config_id):
     """
     Write long-term memory with different storage types
-    
+
     Handles both RAG-based storage and traditional memory storage approaches.
     For traditional storage, uses chunk-based strategy with paired user-AI messages.
-    
+
     Args:
         storage_type: Type of storage (RAG or traditional)
         end_user_id: User group identifier
@@ -95,7 +96,7 @@ async def write_long_term(storage_type,end_user_id,message_chat,aimessages,user_
     """
     from app.core.memory.agent.langgraph_graph.routing.write_router import write_rag_agent
     from app.core.memory.agent.langgraph_graph.routing.write_router import term_memory_save
-    from app.core.memory.agent.langgraph_graph.tools.write_tool import  agent_chat_messages
+    from app.core.memory.agent.langgraph_graph.tools.write_tool import agent_chat_messages
     if storage_type == AgentMemory_Long_Term.STORAGE_RAG:
         await write_rag_agent(end_user_id, message_chat, aimessages, user_rag_memory_id)
     else:
@@ -128,4 +129,4 @@ async def write_long_term(storage_type,end_user_id,message_chat,aimessages,user_
 #
 # if __name__ == "__main__":
 #     import asyncio
-#     asyncio.run(main())
+#     asyncio.run(main())

api/app/core/memory/agent/utils/llm_tools.py

@@ -8,10 +8,11 @@ from langgraph.graph import add_messages
 
 PROJECT_ROOT_ = str(Path(__file__).resolve().parents[3])
 
+
 class WriteState(TypedDict):
-    '''
+    """
     Langgrapg Writing TypedDict
-    '''
+    """
     messages: Annotated[list[AnyMessage], add_messages]
     end_user_id: str
     errors: list[dict]  # Track errors: [{"tool": "tool_name", "error": "message"}]
@@ -20,6 +21,7 @@ class WriteState(TypedDict):
     data: str
     language: str  # 语言类型 ("zh" 中文, "en" 英文)
 
+
 class ReadState(TypedDict):
     """
     LangGraph 工作流状态定义
@@ -43,18 +45,20 @@ class ReadState(TypedDict):
     config_id: str
     data: str  # 新增字段用于传递内容
     spit_data: dict  # 新增字段用于传递问题分解结果
-    problem_extension:dict
+    problem_extension: dict
     storage_type: str
     user_rag_memory_id: str
     llm_id: str
     embedding_id: str
     memory_config: object  # 新增字段用于传递内存配置对象
-    retrieve:dict
+    retrieve: dict
     RetrieveSummary: dict
     InputSummary: dict
     verify: dict
     SummaryFails: dict
     summary: dict
+
+
 class COUNTState:
     """
     工作流对话检索内容计数器
@@ -99,6 +103,7 @@ class COUNTState:
         self.total = 0
         print("[COUNTState] 已重置为 0")
 
+
 def deduplicate_entries(entries):
     seen = set()
     deduped = []
@@ -109,6 +114,7 @@ def deduplicate_entries(entries):
             deduped.append(entry)
     return deduped
 
+
 def merge_to_key_value_pairs(data, query_key, result_key):
     grouped = defaultdict(list)
     for item in data:
@@ -142,4 +148,4 @@ def convert_extended_question_to_question(data):
         return [convert_extended_question_to_question(item) for item in data]
     else:
         # 其他类型直接返回
-        return data
+        return data

api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/triplet_extraction.py

@@ -5,7 +5,7 @@ from typing import List, Dict, Optional
 from app.core.logging_config import get_memory_logger
 from app.core.memory.llm_tools.openai_client import OpenAIClient
 from app.core.memory.utils.prompt.prompt_utils import render_triplet_extraction_prompt
-from app.core.memory.utils.data.ontology import PREDICATE_DEFINITIONS, Predicate # 引入枚举 Predicate 白名单过滤
+from app.core.memory.utils.data.ontology import PREDICATE_DEFINITIONS, Predicate  # 引入枚举 Predicate 白名单过滤
 from app.core.memory.models.triplet_models import TripletExtractionResponse
 from app.core.memory.models.message_models import DialogData, Statement
 from app.core.memory.models.ontology_extraction_models import OntologyTypeList
@@ -14,15 +14,15 @@ from app.core.memory.utils.log.logging_utils import prompt_logger
 logger = get_memory_logger(__name__)
 
 
-
 class TripletExtractor:
     """Extracts knowledge triplets and entities from statements using LLM"""
 
     def __init__(
-        self,
-        llm_client: OpenAIClient,
-        ontology_types: Optional[OntologyTypeList] = None,
-        language: str = "zh"):
+            self,
+            llm_client: OpenAIClient,
+            ontology_types: Optional[OntologyTypeList] = None,
+            language: str = "zh"
+    ):
         """Initialize the TripletExtractor with an LLM client
 
         Args:
@@ -65,7 +65,8 @@ class TripletExtractor:
 
         # Create messages for LLM
         messages = [
-            {"role": "system", "content": "You are an expert at extracting knowledge triplets and entities from text. Follow the provided instructions carefully and return valid JSON."},
+            {"role": "system",
+             "content": "You are an expert at extracting knowledge triplets and entities from text. Follow the provided instructions carefully and return valid JSON."},
             {"role": "user", "content": prompt_content}
         ]
 
@@ -116,7 +117,8 @@ class TripletExtractor:
             logger.error(f"Error processing statement: {e}", exc_info=True)
             return TripletExtractionResponse(triplets=[], entities=[])
 
-    async def extract_triplets_from_statements(self, dialog_data: DialogData, limit_chunks: int = None) -> Dict[str, TripletExtractionResponse]:
+    async def extract_triplets_from_statements(self, dialog_data: DialogData, limit_chunks: int = None) -> Dict[
+        str, TripletExtractionResponse]:
         """Extract triplets and entities from statements
 
         Args:

api/app/core/memory/utils/prompt/template_render.py

@@ -2,15 +2,15 @@ import os
 from jinja2 import Environment, FileSystemLoader
 from typing import List, Dict, Any
 
-
 # Setup Jinja2 environment
 prompt_dir = os.path.join(os.path.dirname(__file__), "prompts")
 prompt_env = Environment(loader=FileSystemLoader(prompt_dir))
 
+
 async def render_evaluate_prompt(evaluate_data: List[Any], schema: Any,
                                  baseline: str = "TIME",
-                                 memory_verify: bool = False,quality_assessment:bool = False,
-                                 statement_databasets: List[str] = [],language_type:str = "zh") -> str:
+                                 memory_verify: bool = False, quality_assessment: bool = False,
+                                 statement_databasets=None, language_type: str = "zh") -> str:
     """
     Renders the evaluate prompt using the evaluate_optimized.jinja2 template.
 
@@ -23,6 +23,8 @@ async def render_evaluate_prompt(evaluate_data: List[Any], schema: Any,
     Returns:
         Rendered prompt content as string
     """
+    if statement_databasets is None:
+        statement_databasets = []
     template = prompt_env.get_template("evaluate.jinja2")
 
     # Convert Pydantic model to JSON schema if needed
@@ -46,7 +48,7 @@ async def render_evaluate_prompt(evaluate_data: List[Any], schema: Any,
 
 
 async def render_reflexion_prompt(data: Dict[str, Any], schema: Any, baseline: str, memory_verify: bool = False,
-                                  statement_databasets: List[str] = [],language_type:str = "zh") -> str:
+                                  statement_databasets=None, language_type: str = "zh") -> str:
     """
     Renders the reflexion prompt using the reflexion_optimized.jinja2 template.
 
@@ -58,6 +60,8 @@ async def render_reflexion_prompt(data: Dict[str, Any], schema: Any, baseline: s
     Returns:
         Rendered prompt content as a string.
     """
+    if statement_databasets is None:
+        statement_databasets = []
     template = prompt_env.get_template("reflexion.jinja2")
 
     # Convert Pydantic model to JSON schema if needed
@@ -69,7 +73,7 @@ async def render_reflexion_prompt(data: Dict[str, Any], schema: Any, baseline: s
         json_schema = schema
 
     rendered_prompt = template.render(data=data, json_schema=json_schema,
-                                      baseline=baseline,memory_verify=memory_verify,
-                                      statement_databasets=statement_databasets,language_type=language_type)
+                                      baseline=baseline, memory_verify=memory_verify,
+                                      statement_databasets=statement_databasets, language_type=language_type)
 
     return rendered_prompt

api/app/core/models/base.py

@@ -1,23 +1,19 @@
 from __future__ import annotations
 
-import asyncio
 import os
-import time
-from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, List, Optional, TypeVar
+from typing import Any, Dict, Optional, TypeVar
+
+from langchain_aws import ChatBedrock
+from langchain_community.chat_models import ChatTongyi
+from langchain_core.embeddings import Embeddings
+from langchain_core.language_models import BaseLLM
+from langchain_ollama import OllamaLLM
+from langchain_openai import ChatOpenAI, OpenAI
+from pydantic import BaseModel, Field
 
-import httpx
 from app.core.error_codes import BizCode
 from app.core.exceptions import BusinessException
 from app.models.models_model import ModelProvider, ModelType
-from langchain_community.document_compressors import JinaRerank
-from langchain_core.callbacks import CallbackManagerForLLMRun
-from langchain_core.embeddings import Embeddings
-from langchain_core.language_models import BaseLanguageModel, BaseLLM
-from langchain_core.outputs import Generation, LLMResult
-from langchain_core.retrievers import BaseRetriever
-from langchain_core.runnables import RunnableSerializable
-from pydantic import BaseModel, Field
 
 T = TypeVar("T")
 
@@ -163,25 +159,17 @@ def get_provider_llm_class(config: RedBearModelConfig, type: ModelType = ModelTy
 
     # dashscope 的 omni 模型使用 OpenAI 兼容模式
     if provider == ModelProvider.DASHSCOPE and config.is_omni:
-        from langchain_openai import ChatOpenAI
         return ChatOpenAI
-
-    if provider in [ModelProvider.OPENAI, ModelProvider.XINFERENCE, ModelProvider.GPUSTACK] :
+    if provider in [ModelProvider.OPENAI, ModelProvider.XINFERENCE, ModelProvider.GPUSTACK]:
         if type == ModelType.LLM:
-            from langchain_openai import OpenAI
             return OpenAI
         elif type == ModelType.CHAT:
-            from langchain_openai import ChatOpenAI
             return ChatOpenAI
     elif provider == ModelProvider.DASHSCOPE:
-        from langchain_community.chat_models import ChatTongyi
         return ChatTongyi
     elif provider == ModelProvider.OLLAMA:
-        from langchain_ollama import OllamaLLM
         return OllamaLLM
     elif provider == ModelProvider.BEDROCK:
-        from langchain_aws import ChatBedrock, ChatBedrockConverse
-
         return ChatBedrock
     else:
         raise BusinessException(f"不支持的模型提供商: {provider}", code=BizCode.PROVIDER_NOT_SUPPORTED)

api/app/core/workflow/nodes/base_node.py

@@ -16,6 +16,7 @@ from app.core.workflow.variable.base_variable import VariableType, FileObject
 from app.db import get_db_read
 from app.models import ModelConfig, ModelApiKey, LoadBalanceStrategy
 from app.schemas import FileInput
+from app.schemas.model_schema import ModelInfo
 from app.services.multimodal_service import MultimodalService
 
 logger = logging.getLogger(__name__)
@@ -620,11 +621,12 @@ class BaseNode(ABC):
 
     @staticmethod
     async def process_message(
-            provider: str,
-            is_omni: bool,
+            api_config: ModelInfo,
             content: str | dict | FileObject,
+            end_user_id: str,
             enable_file=False
     ) -> list | str | None:
+        provider = api_config.provider
         if isinstance(content, dict):
             content = FileObject(
                 type=content.get("type"),
@@ -643,7 +645,7 @@ class BaseNode(ABC):
             if content.content_cache.get(provider):
                 return content.content_cache[provider]
             with get_db_read() as db:
-                multimodel_service = MultimodalService(db, provider, is_omni=is_omni)
+                multimodel_service = MultimodalService(db, api_config=api_config)
                 file_obj = FileInput(
                     type=content.type,
                     url=content.url,
@@ -653,7 +655,8 @@ class BaseNode(ABC):
                 )
                 file_obj.set_content(content.get_content())
                 message = await multimodel_service.process_files(
-                    [file_obj]
+                    end_user_id,
+                    [file_obj],
                 )
                 content.set_content(file_obj.get_content())
                 if message:

api/app/core/workflow/nodes/if_else/node.py

@@ -5,7 +5,7 @@ from typing import Any
 from app.core.workflow.engine.state_manager import WorkflowState
 from app.core.workflow.engine.variable_pool import VariablePool
 from app.core.workflow.nodes.base_node import BaseNode
-from app.core.workflow.nodes.enums import ComparisonOperator, LogicOperator
+from app.core.workflow.nodes.enums import ComparisonOperator, LogicOperator, ValueInputType
 from app.core.workflow.nodes.if_else import IfElseNodeConfig
 from app.core.workflow.nodes.operators import ConditionExpressionResolver, CompareOperatorInstance
 from app.core.workflow.variable.base_variable import VariableType
@@ -23,6 +23,26 @@ class IfElseNode(BaseNode):
             "output": VariableType.STRING
         }
 
+    def _extract_input(self, state: WorkflowState, variable_pool: VariablePool) -> dict[str, Any]:
+        result = []
+        for case in self.typed_config.cases:
+            expressions = []
+            for expression in case.expressions:
+                expressions.append({
+                    "left": self.get_variable(expression.left, variable_pool, strict=False),
+                    "right": expression.right
+                    if expression.input_type == ValueInputType.CONSTANT
+                    else self.get_variable(expression.right, variable_pool, strict=False),
+                    "operator": expression.operator,
+                })
+            result.append({
+                "expressions": expressions,
+                "logical_operator": case.logical_operator,
+            })
+        return {
+            "cases": result
+        }
+
     @staticmethod
     def _evaluate(operator, instance: CompareOperatorInstance) -> Any:
         match operator:

api/app/core/workflow/nodes/knowledge/node.py

@@ -30,6 +30,12 @@ class KnowledgeRetrievalNode(BaseNode):
             "output": VariableType.ARRAY_STRING
         }
 
+    def _extract_input(self, state: WorkflowState, variable_pool: VariablePool) -> dict[str, Any]:
+        return {
+            "query": self._render_template(self.typed_config.query, variable_pool),
+            "knowledge_bases": [kb_config.model_dump(mode="json") for kb_config in self.typed_config.knowledge_bases],
+        }
+
     @staticmethod
     def _build_kb_filter(kb_ids: list[uuid.UUID], permission: knowledge_model.PermissionType):
         """

api/app/core/workflow/nodes/llm/node.py

@@ -20,6 +20,7 @@ from app.core.workflow.nodes.llm.config import LLMNodeConfig
 from app.core.workflow.variable.base_variable import VariableType
 from app.db import get_db_context
 from app.models import ModelType
+from app.schemas.model_schema import ModelInfo
 from app.services.model_service import ModelConfigService
 
 logger = logging.getLogger(__name__)
@@ -113,12 +114,15 @@ class LLMNode(BaseNode):
 
             # 在 Session 关闭前提取所有需要的数据
             api_config = self.model_balance(config)
-            model_name = api_config.model_name
-            provider = api_config.provider
-            api_key = api_config.api_key
-            api_base = api_config.api_base
-            is_omni = api_config.is_omni
-            model_type = config.type
+            model_info = ModelInfo(
+                model_name=api_config.model_name,
+                model_type=ModelType(config.type),
+                api_key=api_config.api_key,
+                api_base=api_config.api_base,
+                provider=api_config.provider,
+                is_omni=api_config.is_omni,
+                capability=api_config.capability
+            )
 
         # 4. 创建 LLM 实例（使用已提取的数据）
         # 注意：对于流式输出，需要在模型初始化时设置 streaming=True
@@ -126,17 +130,18 @@ class LLMNode(BaseNode):
 
         llm = RedBearLLM(
             RedBearModelConfig(
-                model_name=model_name,
-                provider=provider,
-                api_key=api_key,
-                base_url=api_base,
+                model_name=model_info.model_name,
+                provider=model_info.provider,
+                api_key=model_info.api_key,
+                base_url=model_info.api_base,
                 extra_params=extra_params,
-                is_omni=is_omni
+                is_omni=model_info.is_omni
             ),
-            type=ModelType(model_type)
+            type=model_info.model_type
         )
 
-        logger.debug(f"创建 LLM 实例: provider={provider}, model={model_name}, streaming={stream}")
+        logger.debug(
+            f"创建 LLM 实例: provider={model_info.provider}, model={model_info.model_name}, streaming={stream}")
 
         messages_config = self.typed_config.messages
 
@@ -148,35 +153,40 @@ class LLMNode(BaseNode):
                 content_template = msg_config.content
                 content_template = self._render_context(content_template, variable_pool)
                 content = self._render_template(content_template, variable_pool)
-
+                user_id = self.get_variable("sys.user_id", variable_pool)
                 # 根据角色创建对应的消息对象
                 if role == "system":
                     messages.append({
                         "role": "system",
-                        "content": await self.process_message(provider, is_omni, content, self.typed_config.vision)
+                        "content": await self.process_message(
+                            model_info,
+                            content,
+                            user_id,
+                            self.typed_config.vision,
+                        )
                     })
                 elif role in ["user", "human"]:
                     messages.append({
                         "role": "user",
-                        "content": await self.process_message(provider, is_omni, content, self.typed_config.vision)
+                        "content": await self.process_message(model_info, content, user_id, self.typed_config.vision)
                     })
                 elif role in ["ai", "assistant"]:
                     messages.append({
                         "role": "assistant",
-                        "content": await self.process_message(provider, is_omni, content, self.typed_config.vision)
+                        "content": await self.process_message(model_info, content, user_id, self.typed_config.vision)
                     })
                 else:
                     logger.warning(f"未知的消息角色: {role}，默认使用 user")
                     messages.append({
                         "role": "user",
-                        "content": await self.process_message(provider, is_omni, content, self.typed_config.vision)
+                        "content": await self.process_message(model_info, content, user_id, self.typed_config.vision)
                     })
 
             if self.typed_config.vision_input and self.typed_config.vision:
                 file_content = []
                 files = variable_pool.get_instance(self.typed_config.vision_input)
                 for file in files.value:
-                    content = await self.process_message(provider, is_omni, file.value, self.typed_config.vision)
+                    content = await self.process_message(model_info, file.value, user_id, self.typed_config.vision)
                     if content:
                         file_content.extend(content)
                 if messages and messages[-1]["role"] == 'user':
@@ -190,14 +200,19 @@ class LLMNode(BaseNode):
                     if isinstance(message["content"], list):
                         file_content = []
                         for file in message["content"]:
-                            content = await self.process_message(provider, is_omni, file, self.typed_config.vision)
+                            content = await self.process_message(model_info, file, user_id, self.typed_config.vision)
                             if content:
                                 file_content.extend(content)
                         history_message.append(
                             {"role": message["role"], "content": file_content}
                         )
                     else:
-                        message["content"] = await self.process_message(provider, is_omni, message["content"], self.typed_config.vision)
+                        message["content"] = await self.process_message(
+                            model_info,
+                            message["content"],
+                            user_id,
+                            self.typed_config.vision
+                        )
                         history_message.append(message)
                 messages = messages[:-1] + history_message + messages[-1:]
             self.messages = messages
@@ -293,7 +308,7 @@ class LLMNode(BaseNode):
 
         # 调用 LLM（流式，支持字符串或消息列表）
         last_meta_data = {}
-        async for chunk in llm.astream(self.messages, stream_usage=True):
+        async for chunk in llm.astream(self.messages):
             # 提取内容
             if hasattr(chunk, 'content'):
                 content = self.process_model_output(chunk.content)

api/app/core/workflow/nodes/parameter_extractor/node.py

@@ -37,6 +37,14 @@ class ParameterExtractorNode(BaseNode):
                 }
         return None
 
+    def _extract_input(self, state: WorkflowState, variable_pool: VariablePool) -> dict[str, Any]:
+        return {
+            "text": self._render_template(self.typed_config.text, variable_pool),
+            "prompt": self._render_template(self.typed_config.prompt, variable_pool),
+            "params": [param.model_dump(mode="json") for param in self.typed_config.params],
+            "model_id": str(self.typed_config.model_id),
+        }
+
     def _output_types(self) -> dict[str, VariableType]:
         outputs = {}
         for param in self.typed_config.params: