agentcrew-ai 0.8.2__py3-none-any.whl → 0.8.4__py3-none-any.whl

AgentCrew/modules/memory/chroma_service.py

@@ -54,7 +54,7 @@ class ChromaMemoryService(BaseMemoryService):
         ## set to groq if key available
         if self.llm_service:
             if self.llm_service.provider_name == "google":
-                self.llm_service.model = "gemini-2.5-flash-lite-preview-06-17"
+                self.llm_service.model = "gemini-2.5-flash-lite"
             elif self.llm_service.provider_name == "claude":
                 self.llm_service.model = "claude-3-5-haiku-latest"
             elif self.llm_service.provider_name == "openai":
@@ -241,88 +241,66 @@ class ChromaMemoryService(BaseMemoryService):
             session_id = operation_data["session_id"]
 
             # Use the existing storage logic but make it synchronous
-            ids = []
-            memory_data = {}
-            # avaialble_ids = collection.get(
-            #     where={
-            #         "agent": agent_name,
-            #     },
-            #     include=[],
-            # )["ids"]
+            memory_data = None
+            retried = 0
             if self.llm_service:
-                try:
-                    # Process with LLM using asyncio.run to handle async call in worker thread
-                    if self.current_conversation_context.get(session_id, ""):
-                        analyzed_prompt = PRE_ANALYZE_WITH_CONTEXT_PROMPT.replace(
-                            "{conversation_context}",
-                            f"""<PREVIOUS_CONVERSATION_CONTEXT>
-    {self.current_conversation_context[session_id]}
-    </PREVIOUS_CONVERSATION_CONTEXT>""",
+                while retried < 3:
+                    try:
+                        # Process with LLM using asyncio.run to handle async call in worker thread
+                        if self.current_conversation_context.get(session_id, ""):
+                            analyzed_prompt = PRE_ANALYZE_WITH_CONTEXT_PROMPT.replace(
+                                "{conversation_context}",
+                                f"""<PREVIOUS_CONVERSATION_CONTEXT>
+        {self.current_conversation_context[session_id]}
+        </PREVIOUS_CONVERSATION_CONTEXT>""",
+                            )
+                        else:
+                            analyzed_prompt = PRE_ANALYZE_PROMPT
+                        analyzed_prompt = (
+                            analyzed_prompt.replace(
+                                "{current_date}",
+                                datetime.today().strftime("%Y-%m-%d %H:%M:%S"),
+                            )
+                            .replace("{user_message}", user_message)
+                            .replace("{assistant_response}", assistant_response)
                         )
-                    else:
-                        analyzed_prompt = PRE_ANALYZE_PROMPT
-                    analyzed_prompt = (
-                        analyzed_prompt.replace(
-                            "{current_date}",
-                            datetime.today().strftime("%Y-%m-%d %H:%M:%S"),
+                        analyzed_text = await self.llm_service.process_message(
+                            analyzed_prompt
                         )
-                        .replace("{user_message}", user_message)
-                        .replace("{assistant_response}", assistant_response)
-                    )
-                    analyzed_text = await self.llm_service.process_message(
-                        analyzed_prompt
-                    )
-                    start_xml = analyzed_text.index("<MEMORY>")
-                    end_xml = analyzed_text.index("</MEMORY>")
-                    xml_content = analyzed_text[start_xml : end_xml + len("</MEMORY>")]
-                    xml_content.replace("&", "&amp;").replace("'", "&apos;").replace(
-                        '"', "&quot;"
-                    )
-                    memory_data = xmltodict.parse(xml_content)
-                    if (
-                        "MEMORY" in memory_data
-                        and "ID" in memory_data["MEMORY"]
-                        and memory_data["MEMORY"]["ID"]
-                    ):
-                        ids.append(memory_data["MEMORY"]["ID"])
-                    # if (
-                    #     "MEMORY" in memory_data
-                    #     and "USER_REQUEST" not in memory_data["MEMORY"]
-                    # ):
-                    #     memory_data["MEMORY"]["USER_REQUEST"] = user_message
-                    # if (
-                    #     "MEMORY" in memory_data
-                    #     and "ASSISTANT_RESPONSE" not in memory_data["MEMORY"]
-                    # ):
-                    #     memory_data["MEMORY"]["ASSISTANT_RESPONSE"] = assistant_response
-
-                except Exception as e:
-                    logger.warning(f"Error processing conversation with LLM: {e}")
-                    # Fallback to simple concatenation if LLM fails
-                    memory_data = {
-                        "MEMORY": {
-                            "DATE": datetime.today().strftime("%Y-%m-%d"),
-                            "USER_REQUEST": user_message,
-                            "ASSISTANT_RESPONSE": assistant_response
-                            if len(assistant_response) < 200
-                            else assistant_response[:197] + "...",
-                        }
-                    }
-            else:
+                        start_xml = analyzed_text.index("<MEMORY>")
+                        end_xml = analyzed_text.index("</MEMORY>")
+                        xml_content = analyzed_text[
+                            start_xml : end_xml + len("</MEMORY>")
+                        ]
+                        xml_content = (
+                            xml_content.replace("&", "&amp;")
+                            .replace("'", "&apos;")
+                            .replace('"', "&quot;")
+                        )
+                        memory_data = xmltodict.parse(xml_content)
+                        break
+                    except Exception as e:
+                        logger.warning(
+                            f"Error processing conversation with LLM: {e} {xml_content}"  # type: ignore
+                        )
+                        retried += 1
+                        continue
+
+            if memory_data is None:
                 # Create the memory document by combining user message and response
                 memory_data = {
                     "MEMORY": {
                         "DATE": datetime.today().strftime("%Y-%m-%d"),
-                        "USER_REQUEST": user_message,
-                        "ASSISTANT_RESPONSE": assistant_response
-                        if len(assistant_response) < 200
-                        else assistant_response[:197] + "...",
+                        "CONVERSATION_NOTES": {
+                            "NOTE": [user_message, assistant_response]
+                        },
                     }
                 }
 
             # Store in ChromaDB (existing logic)
-            memory_id = str(uuid.uuid4())
             timestamp = datetime.now().timestamp()
+
+            memory_header = memory_data["MEMORY"].get("HEAD", None)
             conversation_document = xmltodict.unparse(
                 memory_data, pretty=True, full_document=False
             )
@@ -335,27 +313,19 @@ class ChromaMemoryService(BaseMemoryService):
 
             metadata = {
                 "date": timestamp,
-                "conversation_id": memory_id,
                 "session_id": session_id,
                 "agent": agent_name,
                 "type": "conversation",
             }
-
-            # Add to ChromaDB collection (existing logic)
-            if ids:
-                collection.upsert(
-                    ids=[ids[0]],
-                    documents=[conversation_document],
-                    embeddings=conversation_embedding,
-                    metadatas=[metadata],
-                )
-            else:
-                collection.add(
-                    documents=[conversation_document],
-                    embeddings=conversation_embedding,
-                    metadatas=[metadata],
-                    ids=[memory_id],
-                )
+            if memory_header:
+                metadata["header"] = memory_header
+
+            collection.upsert(
+                ids=[f"{session_id}_{agent_name}"],
+                documents=[conversation_document],
+                embeddings=conversation_embedding,
+                metadatas=[metadata],
+            )
 
             logger.debug(f"Stored conversation: {operation_data['operation_id']}")
 
@@ -388,7 +358,7 @@ class ChromaMemoryService(BaseMemoryService):
         self.current_conversation_context = {}
         self.context_embedding = []
 
-    def load_conversation_context(self, session_id: str):
+    def load_conversation_context(self, session_id: str, agent_name: str = "None"):
         collection = self._initialize_collection()
         latest_memory = collection.get(
             where={
@@ -425,7 +395,7 @@ class ChromaMemoryService(BaseMemoryService):
         else:
             return input
 
-    def list_memory_ids(
+    def list_memory_headers(
         self,
         from_date: Optional[int] = None,
         to_date: Optional[int] = None,
@@ -450,9 +420,14 @@ class ChromaMemoryService(BaseMemoryService):
             else and_conditions[0]
             if and_conditions
             else None,
-            include=[],
+            include=["metadatas"],
         )
-        return list_memory["ids"]
+        headers = []
+        if list_memory and list_memory["metadatas"]:
+            for metadata in list_memory["metadatas"]:
+                if metadata.get("header", None):
+                    headers.append(metadata.get("header"))
+        return headers
 
     def retrieve_memory(
         self,
@@ -498,36 +473,30 @@ class ChromaMemoryService(BaseMemoryService):
         if not results["documents"] or not results["documents"][0]:
             return "No relevant memories found."
 
-        # Group chunks by conversation_id
-        conversation_chunks = {}
-        for i, (doc, metadata) in enumerate(
-            zip(results["documents"][0], results["metadatas"][0])  # type:ignore
+        conversation_chunks = []
+        for i, (id, doc, metadata) in enumerate(
+            zip(results["ids"][0], results["documents"][0], results["metadatas"][0])  # type:ignore
         ):
-            conv_id = metadata.get("conversation_id", "unknown")
-            if conv_id not in conversation_chunks:
-                conversation_chunks[conv_id] = {
-                    "chunks": [],
+            conversation_chunks.append(
+                {
+                    "id": id,
+                    "document": doc,
                     "timestamp": metadata.get("date", None)
                     or metadata.get("timestamp", "unknown"),
                     "relevance": results["distances"][0][i]
                     if results["distances"]
                     else 99,
                 }
-            conversation_chunks[conv_id]["chunks"].append(
-                (metadata.get("chunk_index", 0), doc)
             )
 
         # Sort conversations by relevance
-        sorted_conversations = sorted(
-            conversation_chunks.items(), key=lambda x: x[1]["relevance"]
-        )
+        sorted_conversations = sorted(conversation_chunks, key=lambda x: x["relevance"])
 
         # Format the output
         output = []
-        for conv_id, conv_data in sorted_conversations:
+        for conv_data in sorted_conversations:
             # Sort chunks by index
-            sorted_chunks = sorted(conv_data["chunks"], key=lambda x: x[0])
-            conversation_text = "\n".join([chunk for _, chunk in sorted_chunks])
+            conversation_text = conv_data["document"]
             if conv_data["relevance"] > RELEVANT_THRESHOLD:
                 continue
             # Format timestamp
@@ -544,22 +513,10 @@ class ChromaMemoryService(BaseMemoryService):
                     timestamp = conv_data["timestamp"]
 
             output.append(
-                f"--- Memory from {timestamp} (relevance point(lower is better): {conv_data['relevance']}) ---\n{conversation_text}\n---"
+                f"--- Memory from {timestamp} [id:{conv_data['id']}] ---\n{conversation_text}\n---"
             )
 
         memories = "\n\n".join(output)
-        # if self.llm_service:
-        #     try:
-        #         return await self.llm_service.process_message(
-        #             POST_RETRIEVE_MEMORY.replace("{keywords}", keywords).replace(
-        #                 "{memory_list}", memories
-        #             )
-        #         )
-        #     except Exception as e:
-        #         logger.warning(f"Error processing retrieved memories with LLM: {e}")
-        #         # Fallback to returning raw memories if LLM processing fails
-        #         return memories
-        # else:
         return memories
 
     def _cosine_similarity(self, vec_a, vec_b):
@@ -663,23 +620,8 @@ class ChromaMemoryService(BaseMemoryService):
                     "count": 0,
                 }
 
-            # Collect all conversation IDs related to the topic
-            conversation_ids = set()
-            if results["metadatas"] and results["metadatas"][0]:
-                for metadata in results["metadatas"][0]:
-                    conv_id = metadata.get("conversation_id")
-                    if conv_id:
-                        conversation_ids.add(conv_id)
-
-            # Get all memories to find those with matching conversation IDs
-            all_memories = collection.get()
-
             # Find IDs to remove
-            ids_to_remove = []
-            if all_memories["metadatas"]:
-                for i, metadata in enumerate(all_memories["metadatas"]):
-                    if metadata.get("conversation_id") in conversation_ids:
-                        ids_to_remove.append(all_memories["ids"][i])
+            ids_to_remove = results["ids"][0]
 
             # Remove the memories
             if ids_to_remove:
@@ -689,7 +631,6 @@ class ChromaMemoryService(BaseMemoryService):
                 "success": True,
                 "message": f"Successfully removed {len(ids_to_remove)} memory chunks related to '{topic}'",
                 "count": len(ids_to_remove),
-                "conversations_affected": len(conversation_ids),
             }
 
         except Exception as e:

AgentCrew/modules/memory/context_persistent.py

@@ -513,7 +513,9 @@ class ContextPersistenceService:
             logger.error(f"ERROR: Failed to store adaptive behavior: {e}")
             return False
 
-    def remove_adaptive_behavior(self, agent_name: str, behavior_id: str) -> bool:
+    def remove_adaptive_behavior(
+        self, agent_name: str, behavior_id: str, is_local: bool = False
+    ) -> bool:
         """
         Removes a specific adaptive behavior for an agent.
 
@@ -524,9 +526,13 @@ class ContextPersistenceService:
         Returns:
             True if successful or behavior didn't exist, False on error.
         """
-        adaptive_data = self._read_json_file(
-            self.adaptive_behaviors_file_path, default_value={}
+
+        adaptive_file_path = (
+            self.adaptive_behaviors_local_path
+            if is_local
+            else self.adaptive_behaviors_file_path
         )
+        adaptive_data = self._read_json_file(adaptive_file_path, default_value={})
 
         if not isinstance(adaptive_data, dict):
             logger.warning("WARNING: Adaptive behaviors file was not a dictionary.")
@@ -540,7 +546,7 @@ class ContextPersistenceService:
                 del adaptive_data[agent_name]
 
             try:
-                self._write_json_file(self.adaptive_behaviors_file_path, adaptive_data)
+                self._write_json_file(adaptive_file_path, adaptive_data)
                 logger.info(
                     f"INFO: Removed adaptive behavior '{behavior_id}' for agent '{agent_name}'"
                 )

AgentCrew/modules/memory/tool.py

@@ -62,12 +62,12 @@ def get_memory_forget_tool_handler(memory_service: BaseMemoryService) -> Callabl
         try:
             result = memory_service.forget_ids(ids, agent_name)
             return (
-                f"✅ Removed memories: {result.get('message', 'Success')}"
+                f"Removed memories: {result.get('message', 'Success')}"
                 if result.get("success")
-                else f"⚠️ Removal incomplete: {result.get('message', 'Not found')}"
+                else f"Removal incomplete: {result.get('message', 'Not found')}"
             )
         except Exception as e:
-            return f"❌ Memories removal failed: {str(e)}"
+            return f"Memories removal failed: {str(e)}"
 
     return handle_memory_forget
 
@@ -162,11 +162,11 @@ def get_memory_retrieve_tool_handler(memory_service: BaseMemoryService) -> Calla
         to_date = params.get("to_date", None)
 
         if not query:
-            raise ValueError("❌ Phrases required for memory search. Try again.")
+            raise ValueError("Phrases required for memory search. Try again.")
 
         if len(query) < 3:
             raise ValueError(
-                f"⚠️ Search term '{query}' too short. Try again with more semantica and descriptive phrases."
+                f"Search term '{query}' too short. Try again with more semantica and descriptive phrases."
             )
 
         # Use provided agent_name or fallback to current agent
@@ -188,13 +188,13 @@ def get_memory_retrieve_tool_handler(memory_service: BaseMemoryService) -> Calla
             )
 
             if not result or result.strip() == "":
-                return f"📝 No memories found for '{query}'. Try broader phrases or related terms."
+                return f"No memories found for '{query}'. Try broader phrases or related terms."
 
             # Count memories for user feedback
-            return f"📚 Found relevant memories:\n\n{result}"
+            return f"Found relevant memories:\n\n{result}"
 
         except Exception as e:
-            return f"❌ Memory search failed: {str(e)}"
+            return f"Memory search failed: {str(e)}"
 
     return handle_memory_retrieve
 
@@ -220,8 +220,7 @@ All behaviors must follow 'when..., [action]...' format for automatic activation
         "scope": {
             "type": "string",
             "enum": ["global", "project"],
-            "default": "global",
-            "description": "Scope of the behavior. 'global' for all interactions, 'project' for current project only. Default is 'global'. Optional.",
+            "description": "Scope of the behavior. 'global' apply for all conversations, 'project' applys for current project only. Use project scope when behavior is project-specific, use global if behavior is general.",
         },
     }
 
@@ -261,32 +260,32 @@ def get_adapt_tool_handler(persistence_service: Any) -> Callable:
         scope = params.get("scope", "global").strip().lower()
 
         if not behavior_id:
-            return "❌ Behavior ID required (e.g., 'communication_style_technical')."
+            return "Behavior ID required (e.g., 'communication_style_technical')."
 
         if not behavior:
-            return "❌ Behavior description required in 'when...do...' format."
+            return "Behavior description required in 'when...do...' format."
 
         # Validate format
         behavior_lower = behavior.lower()
         if not behavior_lower.startswith("when "):
-            return "❌ Use format: 'when [condition], [action]'"
+            return "Use format: 'when [condition], [action]'"
 
         current_agent = AgentManager.get_instance().get_current_agent()
         agent_name = current_agent.name if current_agent else "default"
 
         try:
             success = persistence_service.store_adaptive_behavior(
-                agent_name, behavior_id, behavior, scope == "local"
+                agent_name, behavior_id, behavior, scope == "project"
             )
             return (
-                f"✅ Stored behavior '{behavior_id}': {behavior}"
+                f"Stored behavior '{behavior_id}': {behavior}"
                 if success
-                else "⚠️ Storage completed but may need verification."
+                else "Storage completed but may need verification."
             )
         except ValueError as e:
-            return f"❌ Invalid format: {str(e)}"
+            return f"Invalid format: {str(e)}"
         except Exception as e:
-            return f"❌ Storage failed: {str(e)}"
+            return f"Storage failed: {str(e)}"
 
     return handle_adapt
 

AgentCrew/modules/openai/response_service.py

@@ -225,8 +225,16 @@ class OpenAIResponseService(BaseLLMService):
             "input": input_data,
             "stream": True,
             "instructions": self.system_prompt or None,
+            "temperature": self.temperature,
         }
 
+        forced_sample_params = ModelRegistry.get_model_sample_params(full_model_id)
+        if forced_sample_params:
+            if forced_sample_params.temperature is not None:
+                stream_params["temperature"] = forced_sample_params.temperature
+            if forced_sample_params.top_p is not None:
+                stream_params["top_p"] = forced_sample_params.top_p
+
         # Add reasoning configuration for thinking models
         if "thinking" in ModelRegistry.get_model_capabilities(full_model_id):
             if self.reasoning_effort:
@@ -251,17 +259,17 @@ class OpenAIResponseService(BaseLLMService):
 
             stream_params["tools"] = all_tools
 
-        # if (
-        #     "structured_output" in ModelRegistry.get_model_capabilities(full_model_id)
-        #     and self.structured_output
-        # ):
-        #     from openai.types import ResponseFormatJSONSchema
-        #
-        #     stream_params["text"] = {
-        #         "format": ResponseFormatJSONSchema.model_validate(
-        #             {"type": "json_schema", "json_schema": self.structured_output}
-        #         )
-        #     }
+        if (
+            "structured_output" in ModelRegistry.get_model_capabilities(full_model_id)
+            and self.structured_output
+        ):
+            stream_params["text"] = {
+                "format": {
+                    "name": "default",
+                    "type": "json_schema",
+                    "json_schema": self.structured_output,
+                }
+            }
 
         return await self.client.responses.create(**stream_params)
 

AgentCrew/modules/openai/service.py

@@ -196,6 +196,7 @@ class OpenAIService(BaseLLMService):
             "stream_options": {"include_usage": True},
             "max_tokens": 20000,
         }
+
         if "thinking" in ModelRegistry.get_model_capabilities(full_model_id):
             stream_params.pop("max_tokens", None)
             if self.reasoning_effort:
@@ -203,6 +204,20 @@ class OpenAIService(BaseLLMService):
         else:
             stream_params["temperature"] = self.temperature
             stream_params["top_p"] = 0.95
+            forced_sample_params = ModelRegistry.get_model_sample_params(full_model_id)
+            if forced_sample_params:
+                if forced_sample_params.temperature is not None:
+                    stream_params["temperature"] = forced_sample_params.temperature
+                if forced_sample_params.top_p is not None:
+                    stream_params["top_p"] = forced_sample_params.top_p
+                if forced_sample_params.frequency_penalty is not None:
+                    stream_params["frequency_penalty"] = (
+                        forced_sample_params.frequency_penalty
+                    )
+                if forced_sample_params.presence_penalty is not None:
+                    stream_params["presence_penalty"] = (
+                        forced_sample_params.presence_penalty
+                    )
 
         # Add system message if provided
         if self.system_prompt:

AgentCrew/modules/prompts/constants.py

@@ -1,13 +1,14 @@
 PRE_ANALYZE_PROMPT = """
 <MEMORY_PROCESSING_REQUEST>
-    Extract this conversation for AI memory storage. Create a comprehensive xml record that includes all fields in <OUTPUT_FORMAT> below.
+    Extract this conversation for AI memory storage. Create a comprehensive xml record must start with <MEMORY> that includes all fields in <OUTPUT_FORMAT> below.
     <OUTPUT_FORMAT>
-    1. ID: meaningful id from summary written as snake_case.
+    1. HEAD: one short sentence that describe this conversation.
     2. DATE: {current_date}
-    3. SUMMARY: Brief summary of the conversation (3-6 sentences)
-    4. CONTEXT: Background information relevant to understanding this exchange
+    3. CONTEXT: Background information relevant to understanding this exchange
+    4. INSIGHTS: Important insights, lessons learned, or conclusions drawn from the conversation
     5. ENTITIES: Important people, organizations, products, or concepts mentioned including essential facts, concepts, or data points discussed about that entity
     6. DOMAINS: The subject domain(s) this conversation relates to
+    7. RESOURCES: Important urls, file paths has been mentioned in conversation.
     8. CONVERSATION_NOTES: The key extracted information from conversation.
     </OUTPUT_FORMAT>
 
@@ -22,7 +23,7 @@ PRE_ANALYZE_PROMPT = """
 
     <PROCESSING_INSTRUCTIONS>
     1. Format each section with its heading in ALL CAPS as a tag wrapped around the content.
-    2. If a section would be empty, include the heading with "None detected" as the content.
+    2. If a section would be empty, include the heading with empty text "" as the content.
     3. Focus on extracting factual information rather than making assumptions.
     4. <CONVERSATION_NOTES> should capture all the key points and the direction of flow of the whole conversation in concise.
     5. No explanations or additional text.
@@ -30,10 +31,12 @@ PRE_ANALYZE_PROMPT = """
 
     <EXAMPLES>
         <MEMORY>
-            <ID>donald_trump</ID>
+            <HEAD>discussion about donald trump</HEAD>
             <DATE>2025-01-03</DATE>
-            <SUMMARY>A summary about Donald Trump</SUMMARY>
-            <CONTEXT>Contact information, background, and other relevant details about Donald Trump</CONTEXT>
+            <CONTEXT>discussed with user about details and facts around Donald Trump</CONTEXT>
+            <INSIGHTS>
+                <INSIGHT>To get accurate information, assistant need to collect from multi sources</INSIGHT>
+            </INSIGHTS>
             <ENTITIES>
                 <ENTITY>
                     <NAME>DONALP TRUMP</NAME>
@@ -43,6 +46,9 @@ PRE_ANALYZE_PROMPT = """
             <DOMAINS>
                 <DOMAIN>Politics</DOMAIN>
             </DOMAINS>
+            <RESOURCES>
+                <RESOURCE>https://en.wikipedia.org/wiki/Donald_Trump</RESOURCE>
+            </RESOURCES>
             <CONVERSATION_NOTES>
                 <NOTE>User asked about Donald Trump's background. Assistant provided details on his presidency and key events.</NOTE>
             </CONVERSATION_NOTES>
@@ -53,16 +59,17 @@ PRE_ANALYZE_PROMPT = """
 
 PRE_ANALYZE_WITH_CONTEXT_PROMPT = """
 <MEMORY_PROCESSING_REQUEST>
-    Extract this conversation for AI memory storage. Create a comprehensive xml record following INSTRUCTIONS that includes all fields in <OUTPUT_FORMAT> below. No explanations or additional text.
+    Extract this conversation for AI memory storage. Create a comprehensive xml record must start with <MEMORY> following INSTRUCTIONS that includes all fields in <OUTPUT_FORMAT> below. No explanations or additional text.
 
     <INSTRUCTIONS>
-    1. ID: use existed id from <PREVIOUS_CONVERSATION_CONTEXT> if available or create one.
+    1. HEAD: update existed HEAD from <PREVIOUS_CONVERSATION_CONTEXT> if available or create one short sentence that describe this conversation.
     2. DATE: {current_date}
-    3. SUMMARY: Merge the SUMMARY of <PREVIOUS_CONVERSATION_CONTEXT> with new CONVERSATION_TURN (3-6 sentences)
-    4. CONTEXT: Merge the CONTEXT of <PREVIOUS_CONVERSATION_CONTEXT> with new context in CONVERSATION_TURN
+    3. CONTEXT: Merge the CONTEXT of <PREVIOUS_CONVERSATION_CONTEXT> with new context in CONVERSATION_TURN
+    4. INSIGHTS: Add to the INSIGHTS of <PREVIOUS_CONVERSATION_CONTEXT> for new important insights, lessons learned, or conclusions drawn from CONVERSATION_TURN.
     5. ENTITIES: Add to the ENTITIES of <PREVIOUS_CONVERSATION_CONTEXT> for new important people, organizations, products, or concepts mentioned in CONVERSATION_TURN including essential facts, concepts, or data points discussed about that entity
     6. DOMAINS: Add to the DOMAINS of <PREVIOUS_CONVERSATION_CONTEXT> for new subject domain(s) in CONVERSATION_TURN related
-    7. CONVERSATION_NOTES: Add the CONVERSATION_NOTES of <PREVIOUS_CONVERSATION_CONTEXT> for new key notes extracted information from CONVERSATION_TURN. PREVIOUS_CONVERSATION_CONTEXT CONVERSATION_NOTES must be keep intact.
+    7. RESOURCES: Add to the RESOURCES of <PREVIOUS_CONVERSATION_CONTEXT> for new important urls, file paths, mentioned in CONVERSATION_TURN
+    8. CONVERSATION_NOTES: Add the CONVERSATION_NOTES of <PREVIOUS_CONVERSATION_CONTEXT> for new key notes extracted information from CONVERSATION_TURN. PREVIOUS_CONVERSATION_CONTEXT CONVERSATION_NOTES must be keep intact.
     </INSTRUCTIONS>
 
     {conversation_context}
@@ -78,10 +85,13 @@ PRE_ANALYZE_WITH_CONTEXT_PROMPT = """
 
     <OUTPUT_FORMAT>
         <MEMORY>
-            <ID>[existed_id]</ID>
+            <HEAD>[head]</HEAD>
             <DATE>[current_date]</DATE>
             <SUMMARY>[merged_summary]</SUMMARY>
             <CONTEXT>[merged_context]</CONTEXT>
+            <INSIGHTS>
+                <INSIGHT>[added_insight]</INSIGHT>
+            </INSIGHTS>
             <ENTITIES>
                 <ENTITY>
                     <NAME>[added_entity_name]</NAME>
@@ -91,6 +101,9 @@ PRE_ANALYZE_WITH_CONTEXT_PROMPT = """
             <DOMAINS>
                 <DOMAIN>[added_domain]</DOMAIN>
             </DOMAINS>
+            <RESOURCES>
+                </RESOURCE>[added_resource]</RESOURCE>
+            </RESOURCES>
             <CONVERSATION_NOTES>
                 <NOTE>[added_notes]</NOTE>
             </CONVERSATION_NOTES>