graphiti-core 0.1.0__py3-none-any.whl

graphiti_core/prompts/dedupe_edges.py

@@ -0,0 +1,154 @@
+"""
+Copyright 2024, Zep Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import json
+from typing import Any, Protocol, TypedDict
+
+from .models import Message, PromptFunction, PromptVersion
+
+
+class Prompt(Protocol):
+    v1: PromptVersion
+    v2: PromptVersion
+    edge_list: PromptVersion
+
+
+class Versions(TypedDict):
+    v1: PromptFunction
+    v2: PromptFunction
+    edge_list: PromptFunction
+
+
+def v1(context: dict[str, Any]) -> list[Message]:
+    return [
+        Message(
+            role='system',
+            content='You are a helpful assistant that de-duplicates relationship from edge lists.',
+        ),
+        Message(
+            role='user',
+            content=f"""
+        Given the following context, deduplicate facts from a list of new facts given a list of existing facts:
+
+        Existing Facts:
+        {json.dumps(context['existing_edges'], indent=2)}
+
+        New Facts:
+        {json.dumps(context['extracted_edges'], indent=2)}
+
+        Task:
+        If any facts in New Facts is a duplicate of a fact in Existing Facts, 
+        do not return it in the list of unique facts.
+
+        Guidelines:
+        1. identical or near identical facts are duplicates
+        2. Facts are also duplicates if they are represented by similar sentences
+        3. Facts will often discuss the same or similar relation between identical entities
+
+        Respond with a JSON object in the following format:
+        {{
+            "unique_facts": [
+                {{
+                    "uuid": "unique identifier of the fact"
+                }}
+            ]
+        }}
+        """,
+        ),
+    ]
+
+
+def v2(context: dict[str, Any]) -> list[Message]:
+    return [
+        Message(
+            role='system',
+            content='You are a helpful assistant that de-duplicates relationship from edge lists.',
+        ),
+        Message(
+            role='user',
+            content=f"""
+        Given the following context, deduplicate edges from a list of new edges given a list of existing edges:
+
+        Existing Edges:
+        {json.dumps(context['existing_edges'], indent=2)}
+
+        New Edges:
+        {json.dumps(context['extracted_edges'], indent=2)}
+
+        Task:
+        1. start with the list of edges from New Edges
+        2. If any edge in New Edges is a duplicate of an edge in Existing Edges, replace the new edge with the existing
+            edge in the list
+        3. Respond with the resulting list of edges
+
+        Guidelines:
+        1. Use both the triplet name and fact of edges to determine if they are duplicates, 
+            duplicate edges may have different names meaning the same thing and slight variations in the facts.
+        2. If you encounter facts that are semantically equivalent or very similar, keep the original edge
+
+        Respond with a JSON object in the following format:
+        {{
+            "new_edges": [
+                {{
+                    "triplet": "source_node_name-edge_name-target_node_name",
+                    "fact": "one sentence description of the fact"
+                }}
+            ]
+        }}
+        """,
+        ),
+    ]
+
+
+def edge_list(context: dict[str, Any]) -> list[Message]:
+    return [
+        Message(
+            role='system',
+            content='You are a helpful assistant that de-duplicates edges from edge lists.',
+        ),
+        Message(
+            role='user',
+            content=f"""
+        Given the following context, find all of the duplicates in a list of facts:
+
+        Facts:
+        {json.dumps(context['edges'], indent=2)}
+
+        Task:
+        If any facts in Facts is a duplicate of another fact, return a new fact with one of their uuid's.
+
+        Guidelines:
+        1. identical or near identical facts are duplicates
+        2. Facts are also duplicates if they are represented by similar sentences
+        3. Facts will often discuss the same or similar relation between identical entities
+        4. The final list should have only unique facts. If 3 facts are all duplicates of each other, only one of their
+            facts should be in the response
+
+        Respond with a JSON object in the following format:
+        {{
+            "unique_facts": [
+                {{
+                    "uuid": "unique identifier of the fact",
+                    "fact": "fact of a unique edge"
+                }}
+            ]
+        }}
+        """,
+        ),
+    ]
+
+
+versions: Versions = {'v1': v1, 'v2': v2, 'edge_list': edge_list}

graphiti_core/prompts/dedupe_nodes.py

@@ -0,0 +1,151 @@
+"""
+Copyright 2024, Zep Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import json
+from typing import Any, Protocol, TypedDict
+
+from .models import Message, PromptFunction, PromptVersion
+
+
+class Prompt(Protocol):
+    v1: PromptVersion
+    v2: PromptVersion
+    node_list: PromptVersion
+
+
+class Versions(TypedDict):
+    v1: PromptFunction
+    v2: PromptFunction
+    node_list: PromptVersion
+
+
+def v1(context: dict[str, Any]) -> list[Message]:
+    return [
+        Message(
+            role='system',
+            content='You are a helpful assistant that de-duplicates nodes from node lists.',
+        ),
+        Message(
+            role='user',
+            content=f"""
+        Given the following context, deduplicate nodes from a list of new nodes given a list of existing nodes:
+
+        Existing Nodes:
+        {json.dumps(context['existing_nodes'], indent=2)}
+
+        New Nodes:
+        {json.dumps(context['extracted_nodes'], indent=2)}
+        
+        Task:
+        1. start with the list of nodes from New Nodes
+        2. If any node in New Nodes is a duplicate of a node in Existing Nodes, replace the new node with the existing
+            node in the list
+        3. Respond with the resulting list of nodes
+
+        Guidelines:
+        1. Use both the name and summary of nodes to determine if they are duplicates, 
+            duplicate nodes may have different names
+
+        Respond with a JSON object in the following format:
+        {{
+            "new_nodes": [
+                {{
+                    "name": "Unique identifier for the node",
+                }}
+            ]
+        }}
+        """,
+        ),
+    ]
+
+
+def v2(context: dict[str, Any]) -> list[Message]:
+    return [
+        Message(
+            role='system',
+            content='You are a helpful assistant that de-duplicates nodes from node lists.',
+        ),
+        Message(
+            role='user',
+            content=f"""
+        Given the following context, deduplicate nodes from a list of new nodes given a list of existing nodes:
+
+        Existing Nodes:
+        {json.dumps(context['existing_nodes'], indent=2)}
+
+        New Nodes:
+        {json.dumps(context['extracted_nodes'], indent=2)}
+        Important:
+        If a node in the new nodes is describing the same entity as a node in the existing nodes, mark it as a duplicate!!!
+        Task:
+        If any node in New Nodes is a duplicate of a node in Existing Nodes, add their names to the output list
+
+        Guidelines:
+        1. Use both the name and summary of nodes to determine if they are duplicates, 
+            duplicate nodes may have different names
+        2. In the output, name should always be the name of the New Node that is a duplicate. duplicate_of should be
+            the name of the Existing Node.
+
+        Respond with a JSON object in the following format:
+        {{
+            "duplicates": [
+                {{
+                    "name": "name of the new node",
+                    "duplicate_of": "name of the existing node"
+                }}
+            ]
+        }}
+        """,
+        ),
+    ]
+
+
+def node_list(context: dict[str, Any]) -> list[Message]:
+    return [
+        Message(
+            role='system',
+            content='You are a helpful assistant that de-duplicates nodes from node lists.',
+        ),
+        Message(
+            role='user',
+            content=f"""
+        Given the following context, deduplicate a list of nodes:
+
+        Nodes:
+        {json.dumps(context['nodes'], indent=2)}
+
+        Task:
+        1. Group nodes together such that all duplicate nodes are in the same list of names
+        2. All duplicate names should be grouped together in the same list
+
+        Guidelines:
+        1. Each name from the list of nodes should appear EXACTLY once in your response
+        2. If a node has no duplicates, it should appear in the response in a list of only one name
+
+        Respond with a JSON object in the following format:
+        {{
+            "nodes": [
+                {{
+                    "names": ["myNode", "node that is a duplicate of myNode"],
+                }}
+            ]
+        }}
+        """,
+        ),
+    ]
+
+
+versions: Versions = {'v1': v1, 'v2': v2, 'node_list': node_list}

graphiti_core/prompts/extract_edge_dates.py

@@ -0,0 +1,60 @@
+from typing import Any, Protocol, TypedDict
+
+from .models import Message, PromptFunction, PromptVersion
+
+
+class Prompt(Protocol):
+    v1: PromptVersion
+
+
+class Versions(TypedDict):
+    v1: PromptFunction
+
+
+def v1(context: dict[str, Any]) -> list[Message]:
+    return [
+        Message(
+            role='system',
+            content='You are an AI assistant that extracts datetime information for graph edges, focusing only on dates directly related to the establishment or change of the relationship described in the edge fact.',
+        ),
+        Message(
+            role='user',
+            content=f"""
+            Edge:
+            Edge Name: {context['edge_name']}
+            Fact: {context['edge_fact']}
+
+            Current Episode: {context['current_episode']}
+            Previous Episodes: {context['previous_episodes']}
+            Reference Timestamp: {context['reference_timestamp']}
+
+            IMPORTANT: Only extract time information if it is part of the provided fact. Otherwise ignore the time mentioned. Make sure to do your best to determine the dates if only the relative time is mentioned. (eg 10 years ago, 2 mins ago) based on the provided reference timestamp
+            If the relationship is not of spanning nature, but you are still able to determine the dates, set the valid_at only.
+            Definitions:
+            - valid_at: The date and time when the relationship described by the edge fact became true or was established.
+            - invalid_at: The date and time when the relationship described by the edge fact stopped being true or ended.
+
+            Task:
+            Analyze the conversation and determine if there are dates that are part of the edge fact. Only set dates if they explicitly relate to the formation or alteration of the relationship itself.
+
+            Guidelines:
+            1. Use ISO 8601 format (YYYY-MM-DDTHH:MM:SSZ) for datetimes.
+            2. Use the reference timestamp as the current time when determining the valid_at and invalid_at dates.
+            3. If no temporal information is found that establishes or changes the relationship, leave the fields as null.
+            4. Do not infer dates from related events. Only use dates that are directly stated to establish or change the relationship.
+			5. For relative time mentions directly related to the relationship, calculate the actual datetime based on the reference timestamp.
+            6. If only a date is mentioned without a specific time, use 00:00:00 (midnight) for that date.
+            7. If only a year is mentioned, use January 1st of that year at 00:00:00.
+            9. Always include the time zone offset (use Z for UTC if no specific time zone is mentioned).
+            Respond with a JSON object:
+            {{
+                "valid_at": "YYYY-MM-DDTHH:MM:SSZ or null",
+                "invalid_at": "YYYY-MM-DDTHH:MM:SSZ or null",
+                "explanation": "Brief explanation of why these dates were chosen or why they were set to null"
+            }}
+            """,
+        ),
+    ]
+
+
+versions: Versions = {'v1': v1}

graphiti_core/prompts/extract_edges.py

@@ -0,0 +1,138 @@
+"""
+Copyright 2024, Zep Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import json
+from typing import Any, Protocol, TypedDict
+
+from .models import Message, PromptFunction, PromptVersion
+
+
+class Prompt(Protocol):
+    v1: PromptVersion
+    v2: PromptVersion
+
+
+class Versions(TypedDict):
+    v1: PromptFunction
+    v2: PromptFunction
+
+
+def v1(context: dict[str, Any]) -> list[Message]:
+    return [
+        Message(
+            role='system',
+            content='You are a helpful assistant that extracts graph edges from provided context.',
+        ),
+        Message(
+            role='user',
+            content=f"""
+        Given the following context, extract new semantic edges (relationships) that need to be added to the knowledge graph:
+
+        Current Graph Structure:
+        {context['relevant_schema']}
+
+        New Nodes:
+        {json.dumps(context['new_nodes'], indent=2)}
+
+        New Episode:
+        Content: {context['episode_content']}
+        Timestamp: {context['episode_timestamp']}
+
+        Previous Episodes:
+        {json.dumps([ep['content'] for ep in context['previous_episodes']], indent=2)}
+
+        Extract new semantic edges based on the content of the current episode, considering the existing graph structure, new nodes, and context from previous episodes.
+
+        Guidelines:
+        1. Create edges only between semantic nodes (not episodic nodes like messages).
+        2. Each edge should represent a clear relationship between two semantic nodes.
+        3. The relation_type should be a concise, all-caps description of the relationship (e.g., LOVES, IS_FRIENDS_WITH, WORKS_FOR).
+        4. Provide a more detailed fact describing the relationship.
+        5. If a relationship seems to update an existing one, create a new edge with the updated information.
+        6. Consider temporal aspects of relationships when relevant.
+        7. Do not create edges involving episodic nodes (like Message 1 or Message 2).
+        8. Use existing nodes from the current graph structure when appropriate.
+
+        Respond with a JSON object in the following format:
+        {{
+            "new_edges": [
+                {{
+                    "relation_type": "RELATION_TYPE_IN_CAPS",
+                    "source_node": "Name of the source semantic node",
+                    "target_node": "Name of the target semantic node",
+                    "fact": "Detailed description of the relationship",
+                    "valid_at": "YYYY-MM-DDTHH:MM:SSZ or null if not explicitly mentioned",
+                    "invalid_at": "YYYY-MM-DDTHH:MM:SSZ or null if ongoing or not explicitly mentioned"
+                }}
+            ]
+        }}
+
+        If no new edges need to be added, return an empty list for "new_edges".
+        """,
+        ),
+    ]
+
+
+def v2(context: dict[str, Any]) -> list[Message]:
+    return [
+        Message(
+            role='system',
+            content='You are a helpful assistant that extracts graph edges from provided context.',
+        ),
+        Message(
+            role='user',
+            content=f"""
+        Given the following context, extract edges (relationships) that need to be added to the knowledge graph:
+        Nodes:
+        {json.dumps(context['nodes'], indent=2)}
+
+        
+
+        Episodes:
+        {json.dumps([ep['content'] for ep in context['previous_episodes']], indent=2)}
+        {context['episode_content']} <-- New Episode
+        
+
+        Extract entity edges based on the content of the current episode, the given nodes, and context from previous episodes.
+
+        Guidelines:
+        1. Create edges only between the provided nodes.
+        2. Each edge should represent a clear relationship between two nodes.
+        3. The relation_type should be a concise, all-caps description of the relationship (e.g., LOVES, IS_FRIENDS_WITH, WORKS_FOR).
+        4. Provide a more detailed fact describing the relationship.
+        5. Consider temporal aspects of relationships when relevant.
+
+        Respond with a JSON object in the following format:
+        {{
+            "edges": [
+                {{
+                    "relation_type": "RELATION_TYPE_IN_CAPS",
+                    "source_node_uuid": "uuid of the source entity node",
+                    "target_node_uuid": "uuid of the target entity node",
+                    "fact": "brief description of the relationship",
+                    "valid_at": "YYYY-MM-DDTHH:MM:SSZ or null if not explicitly mentioned",
+                    "invalid_at": "YYYY-MM-DDTHH:MM:SSZ or null if ongoing or not explicitly mentioned"
+                }}
+            ]
+        }}
+
+        If no edges need to be added, return an empty list for "edges".
+        """,
+        ),
+    ]
+
+
+versions: Versions = {'v1': v1, 'v2': v2}

graphiti_core/prompts/extract_nodes.py

@@ -0,0 +1,145 @@
+"""
+Copyright 2024, Zep Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import json
+from typing import Any, Protocol, TypedDict
+
+from .models import Message, PromptFunction, PromptVersion
+
+
+class Prompt(Protocol):
+    v1: PromptVersion
+    v2: PromptVersion
+    extract_json: PromptVersion
+
+
+class Versions(TypedDict):
+    v1: PromptFunction
+    v2: PromptFunction
+    extract_json: PromptFunction
+
+
+def v1(context: dict[str, Any]) -> list[Message]:
+    return [
+        Message(
+            role='system',
+            content='You are a helpful assistant that extracts graph nodes from provided context.',
+        ),
+        Message(
+            role='user',
+            content=f"""
+        Given the following context, extract new entity nodes that need to be added to the knowledge graph:
+
+        Previous Episodes:
+        {json.dumps([ep['content'] for ep in context['previous_episodes']], indent=2)}
+
+        New Episode:
+        Content: {context["episode_content"]}
+
+        Extract new entity nodes based on the content of the current episode, while considering the context from previous episodes.
+
+        Guidelines:
+        1. Focus on entities, concepts, or actors that are central to the current episode.
+        2. Avoid creating nodes for relationships or actions (these will be handled as edges later).
+        3. Provide a brief but informative summary for each node.
+
+        Respond with a JSON object in the following format:
+        {{
+            "new_nodes": [
+                {{
+                    "name": "Unique identifier for the node",
+                    "labels": ["Entity", "OptionalAdditionalLabel"],
+                    "summary": "Brief summary of the node's role or significance"
+                }}
+            ]
+        }}
+
+        If no new nodes need to be added, return an empty list for "new_nodes".
+        """,
+        ),
+    ]
+
+
+def v2(context: dict[str, Any]) -> list[Message]:
+    sys_prompt = """You are an AI assistant that extracts entity nodes from conversational text. Your primary task is to identify and extract the speaker and other significant entities mentioned in the conversation."""
+
+    user_prompt = f"""
+Given the following conversation, extract entity nodes from the CURRENT MESSAGE that are explicitly or implicitly mentioned:
+
+Conversation:
+{json.dumps([ep['content'] for ep in context['previous_episodes']], indent=2)}
+<CURRENT MESSAGE>
+{context["episode_content"]}
+
+Guidelines:
+1. ALWAYS extract the speaker/actor as the first node. The speaker is the part before the colon in each line of dialogue.
+2. Extract other significant entities, concepts, or actors mentioned in the conversation.
+3. Provide concise but informative summaries for each extracted node.
+4. Avoid creating nodes for relationships or actions.
+5. Avoid creating nodes for temporal information like dates, times or years (these will be added to edges later).
+
+Respond with a JSON object in the following format:
+{{
+    "extracted_nodes": [
+        {{
+            "name": "Unique identifier for the node (use the speaker's name for speaker nodes)",
+            "labels": ["Entity", "Speaker" for speaker nodes, "OptionalAdditionalLabel"],
+            "summary": "Brief summary of the node's role or significance"
+        }}
+    ]
+}}
+"""
+    return [
+        Message(role='system', content=sys_prompt),
+        Message(role='user', content=user_prompt),
+    ]
+
+
+def extract_json(context: dict[str, Any]) -> list[Message]:
+    sys_prompt = """You are an AI assistant that extracts entity nodes from conversational text. 
+    Your primary task is to identify and extract relevant entities from JSON files"""
+
+    user_prompt = f"""
+Given the following source description, extract relevant entity nodes from the provided JSON:
+
+Source Description:
+{context["source_description"]}
+
+JSON:
+{context["episode_content"]}
+
+Guidelines:
+1. Always try to extract an entities that the JSON represents. This will often be something like a "name" or "user field
+2. Do NOT extract any properties that contain dates
+
+Respond with a JSON object in the following format:
+{{
+    "extracted_nodes": [
+        {{
+            "name": "Unique identifier for the node (use the speaker's name for speaker nodes)",
+            "labels": ["Entity", "Speaker" for speaker nodes, "OptionalAdditionalLabel"],
+            "summary": "Brief summary of the node's role or significance"
+        }}
+    ]
+}}
+"""
+    return [
+        Message(role='system', content=sys_prompt),
+        Message(role='user', content=user_prompt),
+    ]
+
+
+versions: Versions = {'v1': v1, 'v2': v2, 'extract_json': extract_json}