agentrun-mem0ai 0.0.11__py3-none-any.whl

agentrun_mem0/graphs/tools.py

@@ -0,0 +1,371 @@
+UPDATE_MEMORY_TOOL_GRAPH = {
+    "type": "function",
+    "function": {
+        "name": "update_graph_memory",
+        "description": "Update the relationship key of an existing graph memory based on new information. This function should be called when there's a need to modify an existing relationship in the knowledge graph. The update should only be performed if the new information is more recent, more accurate, or provides additional context compared to the existing information. The source and destination nodes of the relationship must remain the same as in the existing graph memory; only the relationship itself can be updated.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "source": {
+                    "type": "string",
+                    "description": "The identifier of the source node in the relationship to be updated. This should match an existing node in the graph.",
+                },
+                "destination": {
+                    "type": "string",
+                    "description": "The identifier of the destination node in the relationship to be updated. This should match an existing node in the graph.",
+                },
+                "relationship": {
+                    "type": "string",
+                    "description": "The new or updated relationship between the source and destination nodes. This should be a concise, clear description of how the two nodes are connected.",
+                },
+            },
+            "required": ["source", "destination", "relationship"],
+            "additionalProperties": False,
+        },
+    },
+}
+
+ADD_MEMORY_TOOL_GRAPH = {
+    "type": "function",
+    "function": {
+        "name": "add_graph_memory",
+        "description": "Add a new graph memory to the knowledge graph. This function creates a new relationship between two nodes, potentially creating new nodes if they don't exist.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "source": {
+                    "type": "string",
+                    "description": "The identifier of the source node in the new relationship. This can be an existing node or a new node to be created.",
+                },
+                "destination": {
+                    "type": "string",
+                    "description": "The identifier of the destination node in the new relationship. This can be an existing node or a new node to be created.",
+                },
+                "relationship": {
+                    "type": "string",
+                    "description": "The type of relationship between the source and destination nodes. This should be a concise, clear description of how the two nodes are connected.",
+                },
+                "source_type": {
+                    "type": "string",
+                    "description": "The type or category of the source node. This helps in classifying and organizing nodes in the graph.",
+                },
+                "destination_type": {
+                    "type": "string",
+                    "description": "The type or category of the destination node. This helps in classifying and organizing nodes in the graph.",
+                },
+            },
+            "required": [
+                "source",
+                "destination",
+                "relationship",
+                "source_type",
+                "destination_type",
+            ],
+            "additionalProperties": False,
+        },
+    },
+}
+
+
+NOOP_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "noop",
+        "description": "No operation should be performed to the graph entities. This function is called when the system determines that no changes or additions are necessary based on the current input or context. It serves as a placeholder action when no other actions are required, ensuring that the system can explicitly acknowledge situations where no modifications to the graph are needed.",
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "required": [],
+            "additionalProperties": False,
+        },
+    },
+}
+
+
+RELATIONS_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "establish_relationships",
+        "description": "Establish relationships among the entities based on the provided text.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "entities": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "source": {"type": "string", "description": "The source entity of the relationship."},
+                            "relationship": {
+                                "type": "string",
+                                "description": "The relationship between the source and destination entities.",
+                            },
+                            "destination": {
+                                "type": "string",
+                                "description": "The destination entity of the relationship.",
+                            },
+                        },
+                        "required": [
+                            "source",
+                            "relationship",
+                            "destination",
+                        ],
+                        "additionalProperties": False,
+                    },
+                }
+            },
+            "required": ["entities"],
+            "additionalProperties": False,
+        },
+    },
+}
+
+
+EXTRACT_ENTITIES_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "extract_entities",
+        "description": "Extract entities and their types from the text.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "entities": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "entity": {"type": "string", "description": "The name or identifier of the entity."},
+                            "entity_type": {"type": "string", "description": "The type or category of the entity."},
+                        },
+                        "required": ["entity", "entity_type"],
+                        "additionalProperties": False,
+                    },
+                    "description": "An array of entities with their types.",
+                }
+            },
+            "required": ["entities"],
+            "additionalProperties": False,
+        },
+    },
+}
+
+UPDATE_MEMORY_STRUCT_TOOL_GRAPH = {
+    "type": "function",
+    "function": {
+        "name": "update_graph_memory",
+        "description": "Update the relationship key of an existing graph memory based on new information. This function should be called when there's a need to modify an existing relationship in the knowledge graph. The update should only be performed if the new information is more recent, more accurate, or provides additional context compared to the existing information. The source and destination nodes of the relationship must remain the same as in the existing graph memory; only the relationship itself can be updated.",
+        "strict": True,
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "source": {
+                    "type": "string",
+                    "description": "The identifier of the source node in the relationship to be updated. This should match an existing node in the graph.",
+                },
+                "destination": {
+                    "type": "string",
+                    "description": "The identifier of the destination node in the relationship to be updated. This should match an existing node in the graph.",
+                },
+                "relationship": {
+                    "type": "string",
+                    "description": "The new or updated relationship between the source and destination nodes. This should be a concise, clear description of how the two nodes are connected.",
+                },
+            },
+            "required": ["source", "destination", "relationship"],
+            "additionalProperties": False,
+        },
+    },
+}
+
+ADD_MEMORY_STRUCT_TOOL_GRAPH = {
+    "type": "function",
+    "function": {
+        "name": "add_graph_memory",
+        "description": "Add a new graph memory to the knowledge graph. This function creates a new relationship between two nodes, potentially creating new nodes if they don't exist.",
+        "strict": True,
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "source": {
+                    "type": "string",
+                    "description": "The identifier of the source node in the new relationship. This can be an existing node or a new node to be created.",
+                },
+                "destination": {
+                    "type": "string",
+                    "description": "The identifier of the destination node in the new relationship. This can be an existing node or a new node to be created.",
+                },
+                "relationship": {
+                    "type": "string",
+                    "description": "The type of relationship between the source and destination nodes. This should be a concise, clear description of how the two nodes are connected.",
+                },
+                "source_type": {
+                    "type": "string",
+                    "description": "The type or category of the source node. This helps in classifying and organizing nodes in the graph.",
+                },
+                "destination_type": {
+                    "type": "string",
+                    "description": "The type or category of the destination node. This helps in classifying and organizing nodes in the graph.",
+                },
+            },
+            "required": [
+                "source",
+                "destination",
+                "relationship",
+                "source_type",
+                "destination_type",
+            ],
+            "additionalProperties": False,
+        },
+    },
+}
+
+
+NOOP_STRUCT_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "noop",
+        "description": "No operation should be performed to the graph entities. This function is called when the system determines that no changes or additions are necessary based on the current input or context. It serves as a placeholder action when no other actions are required, ensuring that the system can explicitly acknowledge situations where no modifications to the graph are needed.",
+        "strict": True,
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "required": [],
+            "additionalProperties": False,
+        },
+    },
+}
+
+RELATIONS_STRUCT_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "establish_relations",
+        "description": "Establish relationships among the entities based on the provided text.",
+        "strict": True,
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "entities": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "source": {
+                                "type": "string",
+                                "description": "The source entity of the relationship.",
+                            },
+                            "relationship": {
+                                "type": "string",
+                                "description": "The relationship between the source and destination entities.",
+                            },
+                            "destination": {
+                                "type": "string",
+                                "description": "The destination entity of the relationship.",
+                            },
+                        },
+                        "required": [
+                            "source",
+                            "relationship",
+                            "destination",
+                        ],
+                        "additionalProperties": False,
+                    },
+                }
+            },
+            "required": ["entities"],
+            "additionalProperties": False,
+        },
+    },
+}
+
+
+EXTRACT_ENTITIES_STRUCT_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "extract_entities",
+        "description": "Extract entities and their types from the text.",
+        "strict": True,
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "entities": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "entity": {"type": "string", "description": "The name or identifier of the entity."},
+                            "entity_type": {"type": "string", "description": "The type or category of the entity."},
+                        },
+                        "required": ["entity", "entity_type"],
+                        "additionalProperties": False,
+                    },
+                    "description": "An array of entities with their types.",
+                }
+            },
+            "required": ["entities"],
+            "additionalProperties": False,
+        },
+    },
+}
+
+DELETE_MEMORY_STRUCT_TOOL_GRAPH = {
+    "type": "function",
+    "function": {
+        "name": "delete_graph_memory",
+        "description": "Delete the relationship between two nodes. This function deletes the existing relationship.",
+        "strict": True,
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "source": {
+                    "type": "string",
+                    "description": "The identifier of the source node in the relationship.",
+                },
+                "relationship": {
+                    "type": "string",
+                    "description": "The existing relationship between the source and destination nodes that needs to be deleted.",
+                },
+                "destination": {
+                    "type": "string",
+                    "description": "The identifier of the destination node in the relationship.",
+                },
+            },
+            "required": [
+                "source",
+                "relationship",
+                "destination",
+            ],
+            "additionalProperties": False,
+        },
+    },
+}
+
+DELETE_MEMORY_TOOL_GRAPH = {
+    "type": "function",
+    "function": {
+        "name": "delete_graph_memory",
+        "description": "Delete the relationship between two nodes. This function deletes the existing relationship.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "source": {
+                    "type": "string",
+                    "description": "The identifier of the source node in the relationship.",
+                },
+                "relationship": {
+                    "type": "string",
+                    "description": "The existing relationship between the source and destination nodes that needs to be deleted.",
+                },
+                "destination": {
+                    "type": "string",
+                    "description": "The identifier of the destination node in the relationship.",
+                },
+            },
+            "required": [
+                "source",
+                "relationship",
+                "destination",
+            ],
+            "additionalProperties": False,
+        },
+    },
+}

agentrun_mem0/graphs/utils.py

@@ -0,0 +1,97 @@
+UPDATE_GRAPH_PROMPT = """
+You are an AI expert specializing in graph memory management and optimization. Your task is to analyze existing graph memories alongside new information, and update the relationships in the memory list to ensure the most accurate, current, and coherent representation of knowledge.
+
+Input:
+1. Existing Graph Memories: A list of current graph memories, each containing source, target, and relationship information.
+2. New Graph Memory: Fresh information to be integrated into the existing graph structure.
+
+Guidelines:
+1. Identification: Use the source and target as primary identifiers when matching existing memories with new information.
+2. Conflict Resolution:
+   - If new information contradicts an existing memory:
+     a) For matching source and target but differing content, update the relationship of the existing memory.
+     b) If the new memory provides more recent or accurate information, update the existing memory accordingly.
+3. Comprehensive Review: Thoroughly examine each existing graph memory against the new information, updating relationships as necessary. Multiple updates may be required.
+4. Consistency: Maintain a uniform and clear style across all memories. Each entry should be concise yet comprehensive.
+5. Semantic Coherence: Ensure that updates maintain or improve the overall semantic structure of the graph.
+6. Temporal Awareness: If timestamps are available, consider the recency of information when making updates.
+7. Relationship Refinement: Look for opportunities to refine relationship descriptions for greater precision or clarity.
+8. Redundancy Elimination: Identify and merge any redundant or highly similar relationships that may result from the update.
+
+Memory Format:
+source -- RELATIONSHIP -- destination
+
+Task Details:
+======= Existing Graph Memories:=======
+{existing_memories}
+
+======= New Graph Memory:=======
+{new_memories}
+
+Output:
+Provide a list of update instructions, each specifying the source, target, and the new relationship to be set. Only include memories that require updates.
+"""
+
+EXTRACT_RELATIONS_PROMPT = """
+
+You are an advanced algorithm designed to extract structured information from text to construct knowledge graphs. Your goal is to capture comprehensive and accurate information. Follow these key principles:
+
+1. Extract only explicitly stated information from the text.
+2. Establish relationships among the entities provided.
+3. Use "USER_ID" as the source entity for any self-references (e.g., "I," "me," "my," etc.) in user messages.
+CUSTOM_PROMPT
+
+Relationships:
+    - Use consistent, general, and timeless relationship types.
+    - Example: Prefer "professor" over "became_professor."
+    - Relationships should only be established among the entities explicitly mentioned in the user message.
+
+Entity Consistency:
+    - Ensure that relationships are coherent and logically align with the context of the message.
+    - Maintain consistent naming for entities across the extracted data.
+
+Strive to construct a coherent and easily understandable knowledge graph by establishing all the relationships among the entities and adherence to the user’s context.
+
+Adhere strictly to these guidelines to ensure high-quality knowledge graph extraction."""
+
+DELETE_RELATIONS_SYSTEM_PROMPT = """
+You are a graph memory manager specializing in identifying, managing, and optimizing relationships within graph-based memories. Your primary task is to analyze a list of existing relationships and determine which ones should be deleted based on the new information provided.
+Input:
+1. Existing Graph Memories: A list of current graph memories, each containing source, relationship, and destination information.
+2. New Text: The new information to be integrated into the existing graph structure.
+3. Use "USER_ID" as node for any self-references (e.g., "I," "me," "my," etc.) in user messages.
+
+Guidelines:
+1. Identification: Use the new information to evaluate existing relationships in the memory graph.
+2. Deletion Criteria: Delete a relationship only if it meets at least one of these conditions:
+   - Outdated or Inaccurate: The new information is more recent or accurate.
+   - Contradictory: The new information conflicts with or negates the existing information.
+3. DO NOT DELETE if their is a possibility of same type of relationship but different destination nodes.
+4. Comprehensive Analysis:
+   - Thoroughly examine each existing relationship against the new information and delete as necessary.
+   - Multiple deletions may be required based on the new information.
+5. Semantic Integrity:
+   - Ensure that deletions maintain or improve the overall semantic structure of the graph.
+   - Avoid deleting relationships that are NOT contradictory/outdated to the new information.
+6. Temporal Awareness: Prioritize recency when timestamps are available.
+7. Necessity Principle: Only DELETE relationships that must be deleted and are contradictory/outdated to the new information to maintain an accurate and coherent memory graph.
+
+Note: DO NOT DELETE if their is a possibility of same type of relationship but different destination nodes. 
+
+For example: 
+Existing Memory: alice -- loves_to_eat -- pizza
+New Information: Alice also loves to eat burger.
+
+Do not delete in the above example because there is a possibility that Alice loves to eat both pizza and burger.
+
+Memory Format:
+source -- relationship -- destination
+
+Provide a list of deletion instructions, each specifying the relationship to be deleted.
+"""
+
+
+def get_delete_messages(existing_memories_string, data, user_id):
+    return DELETE_RELATIONS_SYSTEM_PROMPT.replace(
+        "USER_ID", user_id
+    ), f"Here are the existing memories: {existing_memories_string} \n\n New Information: {data}"

agentrun_mem0/llms/anthropic.py

@@ -0,0 +1,87 @@
+import os
+from typing import Dict, List, Optional, Union
+
+try:
+    import anthropic
+except ImportError:
+    raise ImportError("The 'anthropic' library is required. Please install it using 'pip install anthropic'.")
+
+from agentrun_mem0.configs.llms.anthropic import AnthropicConfig
+from agentrun_mem0.configs.llms.base import BaseLlmConfig
+from agentrun_mem0.llms.base import LLMBase
+
+
+class AnthropicLLM(LLMBase):
+    def __init__(self, config: Optional[Union[BaseLlmConfig, AnthropicConfig, Dict]] = None):
+        # Convert to AnthropicConfig if needed
+        if config is None:
+            config = AnthropicConfig()
+        elif isinstance(config, dict):
+            config = AnthropicConfig(**config)
+        elif isinstance(config, BaseLlmConfig) and not isinstance(config, AnthropicConfig):
+            # Convert BaseLlmConfig to AnthropicConfig
+            config = AnthropicConfig(
+                model=config.model,
+                temperature=config.temperature,
+                api_key=config.api_key,
+                max_tokens=config.max_tokens,
+                top_p=config.top_p,
+                top_k=config.top_k,
+                enable_vision=config.enable_vision,
+                vision_details=config.vision_details,
+                http_client_proxies=config.http_client,
+            )
+
+        super().__init__(config)
+
+        if not self.config.model:
+            self.config.model = "claude-3-5-sonnet-20240620"
+
+        api_key = self.config.api_key or os.getenv("ANTHROPIC_API_KEY")
+        self.client = anthropic.Anthropic(api_key=api_key)
+
+    def generate_response(
+        self,
+        messages: List[Dict[str, str]],
+        response_format=None,
+        tools: Optional[List[Dict]] = None,
+        tool_choice: str = "auto",
+        **kwargs,
+    ):
+        """
+        Generate a response based on the given messages using Anthropic.
+
+        Args:
+            messages (list): List of message dicts containing 'role' and 'content'.
+            response_format (str or object, optional): Format of the response. Defaults to "text".
+            tools (list, optional): List of tools that the model can call. Defaults to None.
+            tool_choice (str, optional): Tool choice method. Defaults to "auto".
+            **kwargs: Additional Anthropic-specific parameters.
+
+        Returns:
+            str: The generated response.
+        """
+        # Separate system message from other messages
+        system_message = ""
+        filtered_messages = []
+        for message in messages:
+            if message["role"] == "system":
+                system_message = message["content"]
+            else:
+                filtered_messages.append(message)
+
+        params = self._get_supported_params(messages=messages, **kwargs)
+        params.update(
+            {
+                "model": self.config.model,
+                "messages": filtered_messages,
+                "system": system_message,
+            }
+        )
+
+        if tools:  # TODO: Remove tools if no issues found with new memory addition logic
+            params["tools"] = tools
+            params["tool_choice"] = tool_choice
+
+        response = self.client.messages.create(**params)
+        return response.content[0].text