graphmemory 0.1.2__tar.gz → 0.2__tar.gz

graphmemory-0.2/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: graphmemory
+Version: 0.2
+Summary: A package for creating a hybrid graph / vector database for use with GraphRAG.
+Home-page: https://github.com/bradAGI/GraphMemory
+Author: BradAGI
+Author-email: cavemen_summary_0f@icloud.com
+License: LICENSE.txt
+Keywords: graphrag graph database rag vector database
+Requires-Dist: duckdb==1.0.0
+Requires-Dist: pydantic==2.7.3

{graphmemory-0.1.2 → graphmemory-0.2}/README.md

@@ -1,7 +1,7 @@
 # GraphMemory - GraphRAG Database
 
 ## Overview
-This project provides an embedded graph database implementation with vector similarity search (VSS) using DuckDB. It includes a Python class `GraphRAG` for managing nodes and edges. 
+This project provides an embedded graph database implementation with vector similarity search (VSS) using DuckDB. It includes a Python class `GraphMemory` for managing nodes and edges. 
 
 Each node has a unique ID, a JSON data field (any arbitrary dictionary), and a vector of floating point values. 
 
@@ -12,37 +12,77 @@ This database can be used for any graph-based RAG application or knowledge graph
 Vector embeddings can be created using [sentence-transformers](https://www.sbert.net/) or other API based models.
 
 ## Installation
-1. Clone the repository:
-    ```sh
-    git clone https://github.com/bradAGI/GraphMemory
-    ```
-2. Install the required packages:
-    ```sh
-    pip install -r requirements.txt
-    ```
+```sh
+pip install graphmemory
+```
 
 ## Usage
 
-### GraphRAG Class
-The `GraphRAG` class provides methods to manage nodes and edges, perform bulk inserts, create indexes, and find nearest neighbors using vector similarity search.
+### GraphMemory Class
+The `GraphMemory` class provides methods to manage nodes and edges, perform bulk inserts, create indexes, and find nearest neighbors using vector similarity search.
 
 ### Auto-Incrementing IDs
 If you do not provide an ID for a node or edge, the database will automatically assign a unique ID.
 
 ### Example
 ```python
-from graphrag.graphrag import GraphRAG
-from graphrag.models import Node, Edge
+from graphmemory import GraphMemory
+from graphmemory.models import Node, Edge
+
+import json
+from openai import OpenAI
+import os
+
+client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
+
+# Use a LLM to extract structured data from a unstructured text (there are a variety of ways to do this)
+text = "George Washington was the first President of the United States and served from 1789 to 1797."
+
+def extract_dict(text):
+    return json.loads(client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[
+            {"role": "system", "content": "Extract structured data from this text: " + text}
+        ]
+        ).choices[0].message.content)
+
+
+gw_dict = extract_dict(text)
+print(gw_dict)
+
+# Output:
+# {
+#   "President": "George Washington",
+#   "Position": "First President",
+#   "Country": "United States",
+#   "Term": "1789-1797"
+# }
+
+def calculate_embedding(input_json):
+    return client.embeddings.create(
+        input=input_json,
+        model="text-embedding-3-small"
+    ).data[0].embedding
+
+
+embedding = calculate_embedding(gw_dict)
+print(embedding)
+
+# Output:
+# [-0.006929283495992422, -0.005336422007530928, ... (omitted for spacing),  0.04664124920964241, -0.024047505110502243]
 
 
 # Initialize the database from disk (make sure to set vector_length correctly)
-graph_db = GraphRAG(database='graph.db', vector_length=3)
+graph_db = GraphMemory(database='graph.db', vector_length=len(embedding))
 
 # Insert nodes
-node1 = Node(data={"name": "George Washington", "role": "President"}, vector=[0.1, 0.2, 0.3])
+node1 = Node(data=gw_dict, vector=embedding)
 node1_id = graph_db.insert_node(node1)
 
-node2 = Node(data={"name": "Thomas Jefferson", "role": "Secretary of State"}, vector=[0.4, 0.5, 0.6])
+text2 = "Thomas Jefferson was the first Secretary of State of the United States and served from 1797 to 1801."
+tj_dict = extract_dict(text2)
+
+node2 = Node(data=tj_dict, vector=calculate_embedding(tj_dict))
 node2_id = graph_db.insert_node(node2)
 
 # Insert edge
@@ -62,49 +102,13 @@ connected_nodes = graph_db.connected_nodes(node1_id)
 print("Connected Nodes:", connected_nodes)
 
 # Find nearest neighbors
-neighbors = graph_db.nearest_neighbors(vector=[0.1, 0.2, 0.3], limit=1)
+neighbors = graph_db.nearest_nodes(calculate_embedding({"President": "George Washington"}), limit=1)
 print("Nearest Neighbors:", neighbors)
-
-# Insert an edge between the two nodes with a relation
-edge = Edge(source_id=node1_id, target_id=node2_id, relation="served_under", weight=0.5)
-graph_db.insert_edge(edge)
-
-# Define the additional nodes for bulk insert
-nodes = [
-    Node(data={"name": "Alexander Hamilton", "role": "Secretary of the Treasury", "term": "1789–1795"}, vector=[0.7, 0.8, 0.9]),
-    Node(data={"name": "Oliver Wolcott Jr.", "role": "Secretary of the Treasury", "term": "1795–1797"}, vector=[1.6, 1.7, 1.8]),
-]
-
-# Bulk insert nodes
-graph_db.bulk_insert_nodes(nodes)
-
-# Define the additional edges for bulk insert
-edges = [
-    Edge(source_id=nodes[0].id, target_id=nodes[1].id, relation="succeeded_by", weight=0.7),
-    Edge(source_id=nodes[1].id, target_id=nodes[2].id, relation="succeeded_by", weight=0.8)
-]
-
-# Bulk insert edges
-graph_db.bulk_insert_edges(edges)
-
-# Delete a node
-graph_db.delete_node(nodes[-1].id)
-
-# Delete an edge
-graph_db.delete_edge(1, 2)
-
-# Find nearest nodes to a given vector by distance
-neighbors = graph_db.nearest_neighbors(vector=[0.1, 0.2, 0.3], limit=2)
-print("Nearest Neighbors:", neighbors)
-
-# Find connected nodes
-connected_nodes = graph_db.connected_nodes(nodes[1].id)
-print("Connected Nodes:", connected_nodes)
 ```
 
-## GraphRAG Class Methods
+## GraphMemory Class Methods
 
-The `GraphRAG` class provides the following public methods for interacting with the graph database:
+The `GraphMemory` class provides the following public methods for interacting with the graph database:
 
 1. `__init__(self, database=None, vector_length=3)`
    - Initializes the database connection and sets up the database schema if necessary.
@@ -136,7 +140,7 @@ The `GraphRAG` class provides the following public methods for interacting with
 10. `create_index(self)`
     - Creates an index on the node vectors to improve search performance.
 
-11. `nearest_neighbors(self, vector: List[float], limit: int) -> List[Neighbor]`
+11. `nearest_nodes(self, vector: List[float], limit: int) -> List[Neighbor]`
     - Finds and returns the nearest neighbor nodes based on vector similarity.
 
 12. `connected_nodes(self, node_id: int) -> List[Node]`

graphmemory-0.2/graphmemory/__init__.py

@@ -0,0 +1,3 @@
+from .database import GraphMemory
+from .models import Node, Edge, NearestNode
+

graphmemory-0.2/graphmemory/database.py

@@ -0,0 +1,429 @@
+import duckdb
+import json
+import os
+import logging
+from contextlib import contextmanager
+from graphmemory.models import Node, Edge, NearestNode
+from typing import List, Any
+from typing import Dict as D
+import uuid
+
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class GraphMemory:
+    def __init__(self, database=None, vector_length=3):
+        self.database = database
+        self.vector_length = vector_length
+        self.conn = duckdb.connect(database=self.database)
+        self._load_vss_extension()
+        self._configure_database()
+
+        if database and os.path.exists(database):
+            self.load_database(database)
+
+        # Check if 'nodes' and 'edges' tables exist, and create them if they do not
+        nodes_exist = self.conn.execute(
+            "SELECT 1 FROM information_schema.tables WHERE table_name = 'nodes';").fetchone()
+        edges_exist = self.conn.execute(
+            "SELECT 1 FROM information_schema.tables WHERE table_name = 'edges';").fetchone()
+
+        if not nodes_exist or not edges_exist:
+            self.create_tables()
+            logger.info("Tables created or verified successfully.")
+
+    def load_database(self, path):
+        if not os.path.exists(path):
+            logger.error(f"Database file not found: {path}")
+            return
+        try:
+            self.conn.execute(f"ATTACH DATABASE '{path}' AS vss;")
+        except duckdb.Error as e:
+            logger.error(f"Error loading database: {e}")
+
+    def _configure_database(self):
+        try:
+            self.conn.execute("SET hnsw_enable_experimental_persistence=true;")
+        except duckdb.Error as e:
+            logger.error(f"Error setting configuration: {e}")
+
+    def _load_vss_extension(self):
+        try:
+            self.conn.execute("INSTALL vss;")
+            self.conn.execute("LOAD vss;")
+        except duckdb.Error as e:
+            logger.error(f"Error loading VSS extension: {e}")
+
+    def set_vector_length(self, vector_length):
+        self.vector_length = vector_length
+        logger.info(f"Vector length set to: {self.vector_length}")
+
+    def create_tables(self):
+        # Correctly format the SQL string to include vector_length
+        self.conn.execute(f"""
+        CREATE TABLE IF NOT EXISTS nodes (
+            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+            type TEXT,
+            properties JSON,
+            vector FLOAT[{self.vector_length}]
+        );
+        """)
+        self.conn.execute(f"""
+        CREATE TABLE IF NOT EXISTS edges (
+            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+            source_id UUID,
+            target_id UUID,
+            relation TEXT,
+            weight FLOAT,
+            FOREIGN KEY (source_id) REFERENCES nodes(id),
+            FOREIGN KEY (target_id) REFERENCES nodes(id)
+        );
+        """)
+        logger.info("Tables 'nodes' and 'edges' created or already exist.")
+        self.conn.commit()
+
+    def insert_node(self, node: Node) -> uuid.UUID:
+        if node.vector and not self._validate_vector(node.vector):
+            logger.error("Invalid vector: Must be a list of float values.")
+            return None
+        try:
+            with self.transaction():
+                result = self.conn.execute(
+                    "INSERT INTO nodes (id, type, properties, vector) VALUES (?, ?, ?, ?) RETURNING id;",
+                    (str(node.id), node.type, json.dumps(node.properties), node.vector if node.vector else [0.0] * self.vector_length)
+                ).fetchone()
+                if result:
+                    logger.info(f"Node inserted with ID: {result[0]}")
+                return result[0] if result else None
+        except duckdb.Error as e:
+            logger.error(f"Error during insert node: {e}")
+            return None
+
+    def insert_edge(self, edge: Edge):
+        try:
+            with self.transaction():
+                # Check if source and target nodes exist
+                source_exists = self.conn.execute(
+                    "SELECT 1 FROM nodes WHERE id = ?", (str(edge.source_id),)).fetchone()
+                target_exists = self.conn.execute(
+                    "SELECT 1 FROM nodes WHERE id = ?", (str(edge.target_id),)).fetchone()
+                if not source_exists or not target_exists:
+                    raise ValueError("Source or target node does not exist.")
+
+                self.conn.execute("INSERT INTO edges (id, source_id, target_id, relation, weight) VALUES (?, ?, ?, ?, ?);", (
+                    str(edge.id), str(edge.source_id), str(edge.target_id), edge.relation, edge.weight))
+        except duckdb.Error as e:
+            logger.error(f"Error during insert edge: {e}")
+        except ValueError as e:
+            logger.error(f"Error during insert edge: {e}")
+            raise
+
+    def bulk_insert_nodes(self, nodes: List[Node]) -> List[Node]:
+        try:
+            with self.transaction():
+                for node in nodes:
+                    result = self.conn.execute(
+                        "INSERT INTO nodes (id, type, properties, vector) VALUES (?, ?, ?, ?) RETURNING id;",
+                        (str(node.id), node.type, json.dumps(node.properties), node.vector if node.vector else None)
+                    ).fetchone()
+                    if result:
+                        node.id = result[0]
+                return nodes
+        except duckdb.Error as e:
+            logger.error(f"Error during bulk insert nodes: {e}")
+            return []
+
+    def bulk_insert_edges(self, edges: List[Edge]):
+        try:
+            with self.transaction():
+                self.conn.executemany(
+                    "INSERT INTO edges (id, source_id, target_id, relation, weight) VALUES (?, ?, ?, ?, ?);",
+                    [(str(edge.id), str(edge.source_id), str(edge.target_id), edge.relation, edge.weight)
+                     for edge in edges]
+                )
+        except duckdb.Error as e:
+            logger.error(f"Error during bulk insert edges: {e}")
+
+    def delete_node(self, node_id: uuid.UUID):
+        try:
+            with self.transaction():
+                self.conn.execute(
+                    "DELETE FROM nodes WHERE id = ?;", (str(node_id),))
+                self.conn.execute(
+                    "DELETE FROM edges WHERE source_id = ? OR target_id = ?;", (str(node_id), str(node_id)))
+        except duckdb.Error as e:
+            logger.error(f"Error deleting node: {e}")
+
+    def delete_edge(self, source_id: uuid.UUID, target_id: uuid.UUID):
+        try:
+            with self.transaction():
+                self.conn.execute(
+                    "DELETE FROM edges WHERE source_id = ? AND target_id = ?;", (str(source_id), str(target_id)))
+        except duckdb.Error as e:
+            logger.error(f"Error deleting edge: {e}")
+
+    def create_index(self):
+        try:
+            self.conn.execute(
+                "CREATE INDEX IF NOT EXISTS vss_idx ON nodes USING HNSW(vector);")
+        except duckdb.Error as e:
+            logger.error(f"Error creating index: {e}")
+
+    def nearest_nodes(self, vector: List[float], limit: int) -> List[NearestNode]:
+        if not self._validate_vector(vector):
+            logger.error("Invalid vector: Must be a list of float values.")
+            return []
+
+        query = f"""
+        SELECT id, type, properties, vector, array_distance(vector, CAST(? AS FLOAT[{self.vector_length}])) AS distance
+        FROM nodes
+        WHERE vector IS NOT NULL
+        ORDER BY distance LIMIT ?;
+        """
+        try:
+            results = self.conn.execute(query, (vector, limit)).fetchall()
+            return [
+                NearestNode(
+                    node=Node(id=row[0], type=row[1], properties=json.loads(row[2]), vector=row[3]),
+                    distance=row[4]
+                ) for row in results
+            ]
+        except duckdb.Error as e:
+            logger.error(f"Error fetching nearest neighbors: {e}")
+            return []
+
+    def connected_nodes(self, node_id: uuid.UUID) -> List[Node]:
+        query = """
+        SELECT n.id, n.type, n.properties, n.vector
+        FROM nodes n
+        WHERE n.id IN (
+                SELECT target_id FROM edges WHERE source_id = ?
+                UNION
+                SELECT source_id FROM edges WHERE target_id = ?
+            );
+        """
+        try:
+            logger.info(
+                f"Executing query to fetch connected nodes for node_id: {node_id}")
+            results = self.conn.execute(query, (str(node_id), str(node_id))).fetchall()
+            if results:
+                connected_nodes = [Node(id=uuid.UUID(str(row[0])), type=row[1], properties=json.loads(row[2]), vector=row[3]) for row in results]
+                logger.info(f"Found {len(connected_nodes)} connected nodes.")
+            else:
+                connected_nodes = []
+                logger.info("No connected nodes found.")
+            return connected_nodes
+        except duckdb.Error as e:
+            logger.error(f"Error fetching connected nodes: {e}")
+            return []
+
+    def nodes_to_json(self) -> List[D[str, Any]]:
+        try:
+            nodes = self.conn.execute(
+                "SELECT id, type, properties, vector FROM nodes;").fetchall()
+            return [{"id": row[0], "type": row[1], "properties": json.loads(row[2]), "vector": row[3]} for row in nodes]
+        except duckdb.Error as e:
+            logger.error(f"Error fetching nodes: {e}")
+            return []
+
+    def edges_to_json(self) -> List[D[str, Any]]:
+        try:
+            edges = self.conn.execute(
+                "SELECT id, source_id, target_id, relation, weight FROM edges;").fetchall()
+            return [{"id": str(row[0]), "source_id": str(row[1]), "target_id": str(row[2]), "relation": row[3], "weight": row[4]} for row in edges]
+        except duckdb.Error as e:
+            logger.error(f"Error fetching edges: {e}")
+            return []
+
+    def get_node(self, node_id: uuid.UUID) -> Node:
+        try:
+            node = self.conn.execute(
+                "SELECT id, type, properties, vector FROM nodes WHERE id = ?;", (str(node_id),)).fetchone()
+            if node:
+                return Node(id=node[0], type=node[1], properties=json.loads(node[2]), vector=node[3])
+            else:
+                return None
+        except duckdb.Error as e:
+            logger.error(f"Error fetching node: {e}")
+            return None
+
+    def nodes_by_attribute(self, attribute, value) -> List[Node]:
+        try:
+            query = f"SELECT id, type, properties, vector FROM nodes WHERE json_extract(properties, '$.{attribute}') = ?;"
+            nodes = self.conn.execute(query, (json.dumps(value),)).fetchall()
+            if nodes:
+                return [Node(id=row[0], type=row[1], properties=json.loads(row[2]), vector=row[3]) for row in nodes]
+            else:
+                return []
+        except duckdb.Error as e:
+            logger.error(f"Error fetching nodes: {e}")
+            return []
+
+    def get_nodes_vector(self, node_id: int) -> List[float]:
+        try:
+            vector = self.conn.execute(
+                "SELECT vector FROM nodes WHERE id = ?;", (node_id,)).fetchone()
+            return vector[0] if vector else []
+        except duckdb.Error as e:
+            logger.error(f"Error fetching vector: {e}")
+            return []
+
+    def print_json(self):
+        nodes_json = self.nodes_to_json()
+        edges_json = self.edges_to_json()
+        print("Nodes JSON:", json.dumps(nodes_json, indent=2))
+        print("Edges JSON:", json.dumps(edges_json, indent=2))
+
+    def cypher(self, cypher_query):
+        sql_query = self._cypher_to_sql(cypher_query)
+        try:
+            results = self.conn.execute(sql_query).fetchall()
+            logger.debug(f"Query results: {results}")
+            return results
+        except duckdb.Error as e:
+            logger.error(f"Error executing SQL query: {e}")
+            return []
+   
+
+    def _cypher_to_sql(self, cypher_query):
+        import re
+        import json  # Added import for json
+        # Define regex patterns for nodes, relationships, and properties
+        node_pattern = re.compile(r"\((\w+)(?::(\w+))?(?:\s*{([^}]+)})?\)")
+        rel_pattern = re.compile(r"\[(\w+)?(?::(\w+))?(?:\s*{([^}]+)})?\]")
+        
+        # Helper function to parse properties
+        def parse_properties(prop_string):
+            properties = {}
+            if prop_string:
+                props = prop_string.split(',')
+                for prop in props:
+                    key, value = prop.split(':')
+                    value = value.strip().strip('"\'')
+                    if value.isdigit():
+                        value = int(value)
+                    elif re.match(r"^\d+?\.\d+?$", value):
+                        value = float(value)
+                    properties[key.strip()] = value
+            return properties
+
+        # Extract MATCH clause
+        match_clause = re.search(r'MATCH\s+(.*)\s+RETURN', cypher_query, re.IGNORECASE)
+        if not match_clause:
+            raise ValueError("Invalid Cypher query: missing MATCH or RETURN clause")
+        match_content = match_clause.group(1).strip()
+
+        # Extract RETURN clause
+        return_clause = re.search(r'RETURN\s+(.*)', cypher_query, re.IGNORECASE)
+        if not return_clause:
+            raise ValueError("Invalid Cypher query: missing RETURN clause")
+        return_content = return_clause.group(1).strip().split(',')
+
+        # Parse nodes and relationships together
+        elements = re.split(r'(\[.*?\])', match_content)
+
+        nodes = []
+        relationships = []
+        for elem in elements:
+            if '(' in elem:
+                match = node_pattern.search(elem)
+                if match:
+                    alias, label, prop_string = match.groups()
+                    nodes.append({
+                        "alias": alias,
+                        "label": label,
+                        "properties": parse_properties(prop_string)
+                    })
+            elif '[' in elem:
+                match = rel_pattern.search(elem)
+                if match:
+                    alias, label, prop_string = match.groups()
+                    relationships.append({
+                        "alias": alias or f"r{len(relationships)+1}",
+                        "label": label,
+                        "properties": parse_properties(prop_string)
+                    })
+
+        # Start building the SQL query
+        sql_query = "SELECT "
+        sql_parts = []
+
+        # Determine what is being returned
+        for item in return_content:
+            item = item.strip()
+            if '.' in item:
+                alias, field = item.split('.')
+                if field == "embedding":
+                    sql_parts.append(f"{alias}.{field}")
+            else:
+                sql_parts.append("*")
+
+        if not sql_parts:
+            sql_parts.append("*")
+
+        from_clause = []
+        where_conditions = []
+
+        # Process nodes and relationships in sequence
+        for i, node in enumerate(nodes):
+            alias, label, properties = node.values()
+            if i == 0:
+                from_clause.append(f"nodes AS {alias}")
+            else:
+                prev_node = nodes[i-1]['alias']
+                rel = relationships[i-1]
+                rel_alias, rel_label, rel_properties = rel.values()
+                from_clause.append(f"JOIN nodes AS {alias} ON {prev_node}.id = {rel_alias}.start_node_id AND {alias}.id = {rel_alias}.end_node_id")
+            
+            if label:
+                where_conditions.append(f"{alias}.type = '{label}'")
+            for prop, val in properties.items():
+                if prop == "embedding":
+                    sql_parts.append(f"{alias}.embedding")
+                else:
+                    if isinstance(val, (int, float)):
+                        where_conditions.append(f"json_extract({alias}.properties, '$.{prop}') = json('{val}')")
+                    else:
+                        where_conditions.append(f"json_extract({alias}.properties, '$.{prop}') = json('{json.dumps(val)}')")
+        
+        for rel in relationships:
+            rel_alias, rel_label, rel_properties = rel.values()
+            if rel_label:
+                where_conditions.append(f"{rel_alias}.type = '{rel_label}'")
+            for prop, val in rel_properties.items():
+                if isinstance(val, (int, float)):
+                    where_conditions.append(f"json_extract({rel_alias}.properties, '$.{prop}') = json('{val}')")
+                else:
+                    where_conditions.append(f"json_extract({rel_alias}.properties, '$.{prop}') = json('{json.dumps(val)}')")
+
+        sql_query += ", ".join(sql_parts)
+        sql_query += " FROM " + " ".join(from_clause)
+
+        if where_conditions:
+            sql_query += " WHERE " + " AND ".join(where_conditions)
+
+        return sql_query + ";"
+
+
+    def _validate_vector(self, vector):
+        return isinstance(vector, list) and len(vector) == self.vector_length and all(isinstance(x, float) for x in vector)
+
+    @contextmanager
+    def transaction(self):
+        try:
+            self.conn.execute("BEGIN TRANSACTION;")
+            yield
+            self.conn.execute("COMMIT;")
+        except Exception as e:
+            self.conn.execute("ROLLBACK;")
+            raise e
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.conn.close()
+        logger.info("Database connection closed.")

graphmemory-0.2/graphmemory/models.py

@@ -0,0 +1,30 @@
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any, Optional
+import uuid
+
+class GraphEntity(BaseModel):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4, description="The unique identifier for the entity.")
+
+    class Config:
+        extra = 'forbid'
+
+class Node(GraphEntity):
+    properties: Optional[Dict[str, Any]] = Field(default_factory=dict, description="Properties of the entity.")
+    type: Optional[str] = Field(default=None, description="Optional label for the node to categorize it, ex: Person")
+    vector: Optional[List[float]] = Field(default_factory=list, description="Vector representation of the node.")
+
+    class Config:
+        extra = 'forbid'
+
+class Edge(GraphEntity):
+    source_id: uuid.UUID
+    target_id: uuid.UUID
+    relation: str = Field(default=None, description="Relation between the source and target nodes")
+    weight: Optional[float] = Field(default=None, description="Weight of the edge")
+
+    class Config:
+        extra = 'forbid'
+
+class NearestNode(BaseModel):
+    node: Node
+    distance: float

graphmemory-0.2/graphmemory.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: graphmemory
+Version: 0.2
+Summary: A package for creating a hybrid graph / vector database for use with GraphRAG.
+Home-page: https://github.com/bradAGI/GraphMemory
+Author: BradAGI
+Author-email: cavemen_summary_0f@icloud.com
+License: LICENSE.txt
+Keywords: graphrag graph database rag vector database
+Requires-Dist: duckdb==1.0.0
+Requires-Dist: pydantic==2.7.3

{graphmemory-0.1.2 → graphmemory-0.2}/graphmemory.egg-info/SOURCES.txt

@@ -1,11 +1,11 @@
 README.md
 setup.py
+graphmemory/__init__.py
+graphmemory/database.py
+graphmemory/models.py
 graphmemory.egg-info/PKG-INFO
 graphmemory.egg-info/SOURCES.txt
 graphmemory.egg-info/dependency_links.txt
 graphmemory.egg-info/requires.txt
 graphmemory.egg-info/top_level.txt
-graphrag/__init__.py
-graphrag/database.py
-graphrag/models.py
 tests/tests.py

graphmemory-0.2/graphmemory.egg-info/requires.txt

@@ -0,0 +1,2 @@
+duckdb==1.0.0
+pydantic==2.7.3

graphmemory-0.2/graphmemory.egg-info/top_level.txt

@@ -0,0 +1 @@
+graphmemory