--no-edit

Author: wangyu-ustc

frontend/public/wechat-qr.png

@@ -0,0 +1,87 @@
+import os
+
+from typing import Annotated, TypedDict, List
+from langgraph.graph import StateGraph, START
+from langgraph.graph.message import add_messages
+from langchain_openai import ChatOpenAI
+from mirix import Mirix
+from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
+from dotenv import load_dotenv
+load_dotenv()
+
+# Configuration
+# OPENAI_API_KEY = 'sk-xxx'  # Replace with your actual OpenAI API key
+# MEM0_API_KEY = 'your-mem0-key'  # Replace with your actual Mem0 API key
+
+# Initialize LangChain and Mem0
+llm = ChatOpenAI(model="gpt-4o-mini")
+API_KEY = os.getenv("AZURE_OPENAI_API_KEY")
+
+mirix_agent = Mirix(
+  api_key=API_KEY,
+  model_provider="azure_opena",
+  config_path="mirix/configs/mirix_azure_example.yaml",
+)
+
+class State(TypedDict):
+    messages: Annotated[List[HumanMessage | AIMessage], add_messages]
+    user_id: str
+
+graph = StateGraph(State)
+
+def chatbot(state: State):
+    messages = state["messages"]
+    user_id = state["user_id"]
+
+    try:
+
+        system_message = mirix_agent.construct_system_message(messages[-1].content, user_id=user_id)
+
+        full_messages = [system_message] + messages
+
+        response = llm.invoke(full_messages)
+
+        # Store the interaction with Mirix
+        try:
+            interaction = f"User: {messages[-1].content}\n\nAssistant: {response.content}"
+            mirix_agent.add(interaction, user_id=user_id)
+        except Exception as e:
+            print(f"Error saving memory: {e}")
+            
+        return {"messages": [response]}
+        
+    except Exception as e:
+        print(f"Error in chatbot: {e}")
+        # Fallback response without memory context
+        response = llm.invoke(messages)
+        return {"messages": [response]}
+
+graph.add_node("chatbot", chatbot)
+graph.add_edge(START, "chatbot")
+graph.add_edge("chatbot", "chatbot")
+
+compiled_graph = graph.compile()
+
+def run_conversation(user_input: str, mem0_user_id: str):
+
+    user = mirix_agent.create_user(user_name='alice')
+
+    config = {"configurable": {"thread_id": user.id}}
+    state = {"messages": [HumanMessage(content=user_input)], "user_id": user.id}
+
+    for event in compiled_graph.stream(state, config):
+        for value in event.values():
+            if value.get("messages"):
+                print("Customer Support:", value["messages"][-1].content)
+                return
+
+if __name__ == "__main__":
+    print("Welcome to Customer Support! How can I assist you today?")
+    mem0_user_id = "alice"  # You can generate or retrieve this based on your user management system
+    while True:
+        user_input = input("You: ")
+        if user_input.lower() in ['quit', 'exit', 'bye']:
+            print("Customer Support: Thank you for contacting us. Have a great day!")
+            break
+        run_conversation(user_input, mem0_user_id)
+

langgraph_integration.py

@@ -1437,6 +1437,97 @@ def build_system_prompt(self, retrieved_memories: dict) -> str:
 
         return system_prompt
 
+    def construct_system_message(self, message: str) -> str:
+        
+        # Step 1: extract topic from "message"
+        topics = None
+        
+        try:
+
+            # Create temporary messages for topic extraction
+            temporary_messages = [prepare_input_message_create(MessageCreate(
+                role=MessageRole.user,
+                content=message,
+            ), self.agent_state.id, wrap_user_message=False, wrap_system_message=True)]
+
+            temporary_messages.append(prepare_input_message_create(MessageCreate(
+                role=MessageRole.user,
+                content="The above are the inputs from the user, please look at these content and extract the topic (brief description of what the user is focusing on) from these content. If there are multiple focuses in these content, then extract them all and put them into one string separated by ';'. Call the function `update_topic` to update the topic with the extracted topics.",
+            ), self.agent_state.id, wrap_user_message=False, wrap_system_message=True))
+
+            temporary_messages = [
+                prepare_input_message_create(MessageCreate(
+                    role=MessageRole.system,
+                    content="You are a helpful assistant that extracts the topic from the user's input.",
+                ), self.agent_state.id, wrap_user_message=False, wrap_system_message=True),
+            ] + temporary_messages
+            
+            # Define the function for topic extraction
+            functions = [{
+                'name': 'update_topic',
+                'description': "Update the topic of the conversation/content. The topic will be used for retrieving relevant information from the database",
+                'parameters': {
+                    'type': 'object',
+                    'properties': {
+                        'topic': {
+                            'type': 'string', 
+                            'description': 'The topic of the current conversation/content. If there are multiple topics then separate them with ";".'}
+                    },
+                    'required': ['topic']
+                },
+            }]
+            
+            # Use LLMClient to extract topics
+            llm_client = LLMClient.create(
+                llm_config=self.agent_state.llm_config,
+                put_inner_thoughts_first=True,
+            )
+            
+            if llm_client:
+                response = llm_client.send_llm_request(
+                    messages=temporary_messages,
+                    tools=functions,
+                    stream=False,
+                    force_tool_call='update_topic',
+                )
+            else:
+                # Fallback to existing create function
+                response = create(
+                    llm_config=self.agent_state.llm_config,
+                    messages=temporary_messages,
+                    functions=functions,
+                    force_tool_call='update_topic',
+                )
+
+            # Extract topics from the response
+            for choice in response.choices:
+                if hasattr(choice.message, 'tool_calls') and choice.message.tool_calls is not None and len(choice.message.tool_calls) > 0:
+                    try:
+                        function_args = json.loads(choice.message.tool_calls[0].function.arguments)
+                        topics = function_args.get('topic')
+                        self.logger.info(f"Extracted topics: {topics}")
+                        break
+                    except (json.JSONDecodeError, KeyError) as parse_error:
+                        self.logger.warning(f"Failed to parse topic extraction response: {parse_error}")
+                        continue
+
+        except Exception as e:
+            self.logger.info(f"Error in extracting the topic from the message: {e}")
+            topics = None
+        
+        # Step 2: build system prompt with topic
+        # Get the raw system prompt
+        in_context_messages = self.agent_manager.get_in_context_messages(agent_id=self.agent_state.id, actor=self.user)
+        raw_system = in_context_messages[0].content[0].text if in_context_messages and in_context_messages[0].role == MessageRole.system else ""
+        
+        # Build the complete system prompt with memories
+        complete_system_prompt, _ = self.build_system_prompt_with_memories(
+            raw_system=raw_system,
+            topics=topics
+        )
+        
+        return complete_system_prompt
+
     def inner_step(
         self,
         first_input_messge: Message,

mirix/agent/agent.py

@@ -262,7 +262,17 @@ def __init__(self, agent_config_file, load_from=None):
 
         # For GEMINI models, extract all unprocessed images and fill temporary_messages
         if self.model_name in GEMINI_MODELS and self.google_client is not None:
-            self._process_existing_uploaded_files()
+            self._process_existing_uploaded_files(user_id=self.client.user.id)
+
+    def construct_system_message(self, 
+                                message: str,
+                                user_id: str) -> str:
+        """
+        Construct a system message from a message.
+        """
+        return self.client.construct_system_message(agent_id=self.agent_states.agent_state.id, 
+                                                    message=message,
+                                                    user_id=user_id)
 
     def update_chat_agent_system_prompt(self, is_screen_monitoring: bool):
         '''
@@ -641,7 +651,7 @@ def _check_and_connect_gmail(self):
             self.logger.warning(f"Error checking Gmail credentials: {e}")
             return False
 
-    def _process_existing_uploaded_files(self):
+    def _process_existing_uploaded_files(self, user_id: str):
         """Process any existing uploaded files for Gemini models."""
         uploaded_mappings = self.client.server.cloud_file_mapping_manager.list_files_with_status(status='uploaded')
 
@@ -2028,7 +2038,7 @@ def _complete_gemini_initialization(self) -> bool:
             self.temp_message_accumulator.uri_to_create_time = self.uri_to_create_time
 
             # Process existing uploaded files
-            self._process_existing_uploaded_files()
+            self._process_existing_uploaded_files(user_id=self.client.user.id)
 
             self.logger.info("Gemini initialization completed successfully!")
             return True

mirix/agent/agent_wrapper.py

@@ -1059,6 +1059,12 @@ def get_in_context_messages(self, agent_id: str) -> List[Message]:
 
     # agent interactions
 
+    def construct_system_message(self, agent_id: str, message: str, user_id: str) -> str:
+        """
+        Construct a system message from a message.
+        """
+        return self.server.construct_system_message(agent_id=agent_id, message=message, actor=self.server.user_manager.get_user_by_id(user_id))
+
     def send_messages(
         self,
         agent_id: str,

mirix/client/client.py

@@ -524,24 +524,29 @@ def trigger_memory_update(self: "Agent", user_message: object, memory_types: Lis
         responses = []
         overall_start = time.time()
 
-        # Use ThreadPoolExecutor for parallel processing
-        with ThreadPoolExecutor(max_workers=len(valid_agent_types)) as pool:
-            futures = []
-            for agent_type in valid_agent_types:
-                matching_agents = [agent for agent in agents if agent.agent_type == agent_type]
-                if not matching_agents:
-                    raise ValueError(f"No agent found with type '{agent_type}'")
-                futures.append(
-                    pool.submit(message_queue.send_message_in_queue, 
-                               client, matching_agents[0].id, payloads, agent_type)
-                )
-            
-            for future in tqdm(as_completed(futures), total=len(futures)):
-                response, agent_type = future.result()
-                responses.append(response)
+        if len(valid_agent_types) > 0: 
+
+            # Use ThreadPoolExecutor for parallel processing
+            with ThreadPoolExecutor(max_workers=len(valid_agent_types)) as pool:
+                futures = []
+                for agent_type in valid_agent_types:
+                    matching_agents = [agent for agent in agents if agent.agent_type == agent_type]
+                    if not matching_agents:
+                        raise ValueError(f"No agent found with type '{agent_type}'")
+                    futures.append(
+                        pool.submit(message_queue.send_message_in_queue, 
+                                client, matching_agents[0].id, payloads, agent_type)
+                    )
+                
+                for future in tqdm(as_completed(futures), total=len(futures)):
+                    response, agent_type = future.result()
+                    responses.append(response)
+
+            overall_end = time.time()
+            response_message = f'[System Message] {len(valid_agent_types)} memory agents have been triggered in parallel to update the memory. Total time: {overall_end - overall_start:.2f} seconds.'
+        else:
+            response_message = '[System Message] Valid agent types are empty. No memory agents have been triggered to update the memory.'
 
-        overall_end = time.time()
-        response_message = f'[System Message] {len(valid_agent_types)} memory agents have been triggered in parallel to update the memory. Total time: {overall_end - overall_start:.2f} seconds.'
         return response_message
 
     else:

mirix/functions/function_sets/memory_tools.py

@@ -162,6 +162,13 @@ def list_users(self) -> Dict[str, Any]:
         users = self._agent.client.server.user_manager.list_users()
         return users
 
+
+    def construct_system_message(self, message: str, user_id: str) -> str:
+        """
+        Construct a system message from a message.
+        """
+        return self._agent.construct_system_message(message, user_id)
+
     def get_user_by_name(self, user_name: str):
         """
         Get a user by their name.

mirix/sdk.py

@@ -831,6 +831,17 @@ def system_message(
         # Run the agent state forward
         return self._step(actor=actor, agent_id=agent_id, input_messages=message)
 
+    def construct_system_message(self, agent_id: str, message: str, actor: User) -> str:
+        """
+        Construct a system message from a message.
+        """
+        logger.debug(f"Got message: {message}")
+        mirix_agent = None
+        mirix_agent = self.load_agent(agent_id=agent_id, actor=actor)
+        if mirix_agent is None:
+            raise KeyError(f"Agent (user={actor.id}, agent={agent_id}) is not loaded")
+        return mirix_agent.construct_system_message(message=message)
+
     def send_messages(
         self,
         actor: User,