memgraph-toolbox 0.1.0__py3-none-any.whl

memgraph_toolbox/api/memgraph.py

@@ -0,0 +1,98 @@
+from typing import Any, Dict, List, Optional
+
+from neo4j import GraphDatabase
+
+
+class Memgraph:
+    """
+    Base Memgraph client for interacting with Memgraph database.
+    """
+
+    def __init__(
+        self,
+        uri: str,
+        username: str,
+        password: str,
+        driver_config: Optional[Dict] = None,
+    ):
+        self.driver = GraphDatabase.driver(
+            uri, auth=(username, password), **(driver_config or {})
+        )
+        try:
+            import neo4j
+        except ImportError:
+            raise ImportError(
+                "Could not import neo4j python package. "
+                "Please install it with `pip install neo4j`."
+            )
+        try:
+            self.driver.verify_connectivity()
+        except neo4j.exceptions.ServiceUnavailable:
+            raise ValueError(
+                "Could not connect to Memgraph database. "
+                "Please ensure that the url is correct"
+            )
+        except neo4j.exceptions.AuthError:
+            raise ValueError(
+                "Could not connect to Memgraph database. "
+                "Please ensure that the username and password are correct"
+            )
+
+    def query(self, query: str, params: dict = {}) -> List[Dict[str, Any]]:
+        """
+        Execute a Cypher query and return results as a list of dictionaries.
+
+        Args:
+            query: The Cypher query to execute
+
+        Returns:
+            List of dictionaries containing query results
+        """
+        from neo4j.exceptions import Neo4jError
+
+        try:
+            data, _, _ = self.driver.execute_query(
+                query,
+                parameters_=params,
+            )
+            json_data = [r.data() for r in data]
+            return json_data
+        except Neo4jError as e:
+            if not (
+                (
+                    (  # isCallInTransactionError
+                        e.code == "Neo.DatabaseError.Statement.ExecutionFailed"
+                        or e.code
+                        == "Neo.DatabaseError.Transaction.TransactionStartFailed"
+                    )
+                    and "in an implicit transaction" in e.message
+                )
+                or (  # isPeriodicCommitError
+                    e.code == "Neo.ClientError.Statement.SemanticError"
+                    and (
+                        "in an open transaction is not possible" in e.message
+                        or "tried to execute in an explicit transaction" in e.message
+                    )
+                )
+                or (
+                    e.code == "Memgraph.ClientError.MemgraphError.MemgraphError"
+                    and ("in multicommand transactions" in e.message)
+                )
+                or (
+                    e.code == "Memgraph.ClientError.MemgraphError.MemgraphError"
+                    and "SchemaInfo disabled" in e.message
+                )
+            ):
+                raise
+
+        # fallback to allow implicit transactions
+        with self.driver.session() as session:
+            data = session.run(query, params)
+            json_data = [r.data() for r in data]
+            return json_data
+
+    def close(self) -> None:
+        """
+        Close the database connection.
+        """
+        self.driver.close()

memgraph_toolbox/api/tool.py

@@ -0,0 +1,51 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List
+
+
+class BaseTool(ABC):
+    """
+    Base class for all tools.
+    """
+
+    name: str
+    description: str
+    input_schema: Dict[str, Any]
+
+    def __init__(self, name: str, description: str, input_schema: Dict[str, Any]):
+        self.name = name
+        self.description = description
+        self.input_schema = input_schema
+
+    @abstractmethod
+    def call(self, arguments: Dict[str, Any]) -> List[Any]:
+        """
+        Execute the tool with the provided arguments.
+
+        Parameters:
+            arguments (dict): A dictionary of arguments as defined by the input schema.
+
+        Returns:
+            List containing one or more output values.
+        """
+        pass
+
+    def __repr__(self):
+        return f"Tool(name={self.name}, description={self.description})"
+
+    def get_name(self) -> str:
+        """
+        Get the name of the tool.
+
+        Returns:
+            str: The name of the tool.
+        """
+        return self.name
+
+    def get_description(self) -> str:
+        """
+        Get the description of the tool.
+
+        Returns:
+            str: The description of the tool.
+        """
+        return self.description

memgraph_toolbox/api/toolkit.py

@@ -0,0 +1,41 @@
+from typing import Dict, List
+from .tool import BaseTool
+
+
+class BaseToolkit:
+    """
+    A Toolkit for managing tools.
+    """
+
+    def __init__(self):
+        self._tools: Dict[str, BaseTool] = {}
+
+    def add_tool(self, tool: BaseTool) -> None:
+        """
+        Add a new tool in the registry.
+
+        Raises:
+            ValueError: If a tool with the same name is already toolkit.
+        """
+        if tool.name in self._tools:
+            raise ValueError(
+                f"Tool with name '{tool.name}' is already present in toolkit."
+            )
+        self._tools[tool.name] = tool
+
+    def get_tool(self, name: str) -> BaseTool:
+        """
+        Retrieve a tool by its name.
+
+        Raises:
+            ValueError: If no tool with the given name is found.
+        """
+        if name not in self._tools:
+            raise ValueError(f"Tool with name '{name}' not found.")
+        return self._tools[name]
+
+    def get_all_tools(self) -> List[BaseTool]:
+        """
+        List all added tools.
+        """
+        return list(self._tools.values())

memgraph_toolbox/tests/test_toolkit.py

@@ -0,0 +1,35 @@
+from typing import Any, Dict, List
+
+import pytest
+
+from ..api.toolkit import BaseToolkit
+from ..api.tool import BaseTool
+from ..utils.logging import logger_init
+
+logger = logger_init("test-toolkit")  # Set up logger for the test
+
+
+def test_toolkit():
+    """Test the Toolkit class."""
+
+    toolkit = BaseToolkit()
+
+    class DummyTool(BaseTool):
+        def __init__(self):
+            super().__init__(
+                name="dummy_tool",
+                description="A dummy tool for testing",
+                input_schema={},
+            )
+
+        def call(self, arguments: Dict[str, Any]) -> List[Any]:
+            return ["dummy_result"]
+
+    dummy_tool = DummyTool()
+    toolkit.add_tool(dummy_tool)
+
+    assert toolkit.get_tool("dummy_tool") == dummy_tool
+    assert len(toolkit.get_all_tools()) == 1
+
+    with pytest.raises(ValueError):
+        toolkit.add_tool(dummy_tool)

memgraph_toolbox/tests/test_tools.py

@@ -0,0 +1,193 @@
+import pytest
+
+from ..api.memgraph import Memgraph
+from ..tools.betweenness_centrality import BetweennessCentralityTool
+from ..tools.config import ShowConfigTool
+from ..tools.constraint import ShowConstraintInfoTool
+from ..tools.cypher import CypherTool
+from ..tools.index import ShowIndexInfoTool
+from ..tools.page_rank import PageRankTool
+from ..tools.schema import ShowSchemaInfoTool
+from ..tools.storage import ShowStorageInfoTool
+from ..tools.trigger import ShowTriggersTool
+from ..utils.logging import logger_init
+
+logger = logger_init("test-tools")
+
+
+def test_show_schema_info_tool():
+    """Test the ShowSchemaInfo tool."""
+
+    uri = "bolt://localhost:7687"
+    user = "memgraph"
+    password = "memgraph"
+
+    memgraph_client = Memgraph(uri=uri, username=user, password=password)
+
+    schema_tool = ShowSchemaInfoTool(db=memgraph_client)
+    assert "show_schema_info" in schema_tool.name
+
+    result = schema_tool.call({})
+
+    assert isinstance(result, list)
+    assert len(result) >= 1
+
+
+def test_show_config_tool():
+    """Test the ShowConfig tool."""
+
+    uri = "bolt://localhost:7687"
+    user = "memgraph"
+    password = "memgraph"
+
+    memgraph_client = Memgraph(uri=uri, username=user, password=password)
+
+    config_tool = ShowConfigTool(db=memgraph_client)
+    assert "show_config" in config_tool.name
+    result = config_tool.call({})
+    assert isinstance(result, list)
+    assert len(result) >= 1
+
+
+def test_index_tool():
+    """Test the ShowIndexInfo tool."""
+
+    uri = "bolt://localhost:7687"
+    user = "memgraph"
+    password = "memgraph"
+
+    memgraph_client = Memgraph(uri=uri, username=user, password=password)
+
+    # Create an index for testing
+
+    memgraph_client.query("CREATE INDEX ON :Person(name)")
+
+    index_tool = ShowIndexInfoTool(db=memgraph_client)
+    assert "show_index_info" in index_tool.name
+    result = index_tool.call({})
+
+    memgraph_client.query("DROP INDEX ON :Person(name)")
+
+    assert isinstance(result, list)
+
+    assert len(result) >= 1
+
+
+def test_storage_tool():
+    """Test the ShowStorageInfo tool."""
+
+    uri = "bolt://localhost:7687"
+    user = "memgraph"
+    password = "memgraph"
+
+    memgraph_client = Memgraph(uri=uri, username=user, password=password)
+
+    storage_tool = ShowStorageInfoTool(db=memgraph_client)
+    assert "show_storage_info" in storage_tool.name
+    result = storage_tool.call({})
+
+    assert isinstance(result, list)
+    assert len(result) >= 1
+
+
+def test_show_constraint_info_tool():
+    """Test the ShowConstraintInfo tool."""
+    uri = "bolt://localhost:7687"
+    user = "memgraph"
+    password = "memgraph"
+    memgraph_client = Memgraph(uri=uri, username=user, password=password)
+    # Create a sample constraint
+    memgraph_client.query("CREATE CONSTRAINT ON (n:Person) ASSERT n.id IS UNIQUE")
+
+    constraint_tool = ShowConstraintInfoTool(db=memgraph_client)
+    result = constraint_tool.call({})
+
+    memgraph_client.query("DROP CONSTRAINT ON (n:Person) ASSERT n.id IS UNIQUE")
+
+    assert isinstance(result, list)
+    assert len(result) > 0
+
+
+def test_show_triggers_tool():
+    """Test the ShowTriggers tool."""
+
+    uri = "bolt://localhost:7687"
+    user = "memgraph"
+    password = "memgraph"
+    memgraph_client = Memgraph(uri=uri, username=user, password=password)
+
+    memgraph_client.query(
+        """
+        CREATE TRIGGER my_trigger ON () CREATE AFTER COMMIT EXECUTE
+        UNWIND createdVertices AS newNodes
+        SET newNodes.created = timestamp();
+        """
+    )
+
+    trigger_tool = ShowTriggersTool(db=memgraph_client)
+    result = trigger_tool.call({})
+
+    memgraph_client.query("DROP TRIGGER my_trigger;")
+
+    assert isinstance(result, list)
+    assert len(result) > 0
+
+
+def test_page_rank():
+    """Test the PageRank tool."""
+
+    uri = "bolt://localhost:7687"
+    user = "memgraph"
+    password = "memgraph"
+    memgraph_client = Memgraph(uri=uri, username=user, password=password)
+
+    # Create a sample graph for testing
+    memgraph_client.query(
+        """UNWIND range(1, 10) AS i
+           CREATE (:Test {id: i})-[:LINK]->(:Test {id: i + 1}); 
+        """
+    )
+
+    # Run the PageRank tool
+    page_rank_tool = PageRankTool(db=memgraph_client)
+    result = page_rank_tool.call({"limit": 20})
+    assert isinstance(result, list)
+    assert len(result) > 0
+
+
+def test_cypher():
+    """Test the Cypher tool."""
+
+    uri = "bolt://localhost:7687"
+    user = "memgraph"
+    password = "memgraph"
+    memgraph_client = Memgraph(uri=uri, username=user, password=password)
+
+    cypher_tool = CypherTool(db=memgraph_client)
+    result = cypher_tool.call({"query": "RETURN 0;"})
+    assert isinstance(result, list)
+    assert len(result) == 1
+
+
+def test_betweenness_centrality_tool():
+    """Test the RunBetweennessCentralityTool."""
+
+    uri = "bolt://localhost:7687"
+    user = "memgraph"
+    password = "memgraph"
+    memgraph_client = Memgraph(uri=uri, username=user, password=password)
+
+    memgraph_client.query(
+        """
+        UNWIND range(1, 5) AS i
+        CREATE (a:Node {id: i})-[:RELATES]->(b:Node {id: i + 1});
+        """
+    )
+
+    betweenness_tool = BetweennessCentralityTool(db=memgraph_client)
+    result = betweenness_tool.call({"isDirectionIgnored": True, "limit": 5})
+
+    assert isinstance(result, list)
+    assert len(result) > 0
+    assert "node" in result[0]
+    assert "betweenness_centrality" in result[0]

memgraph_toolbox/tools/betweenness_centrality.py

@@ -0,0 +1,57 @@
+from typing import Any, Dict, List
+
+from ..api.memgraph import Memgraph
+from ..api.tool import BaseTool
+
+
+class BetweennessCentralityTool(BaseTool):
+    """
+    Tool for calculating betweenness centrality on a graph in Memgraph.
+    """
+
+    def __init__(self, db: Memgraph):
+        super().__init__(
+            name="run_betweenness_centrality",
+            description=(
+                "Calculates betweenness centrality for nodes in a graph. "
+                "Betweenness centrality measures the importance of a node based on how frequently "
+                "it lies on the shortest paths between other nodes, indicating its influence on "
+                "information flow within the network."
+            ),
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "isDirectionIgnored": {
+                        "type": "boolean",
+                        "description": "Set to false to consider the direction of relationships. Default is true.",
+                        "default": True,
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Limit the number of nodes to return. Default is 10.",
+                        "default": 10,
+                    },
+                },
+                "required": [],
+            },
+        )
+        self.db = db
+
+    def call(self, arguments: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Execute the betweenness centrality algorithm and return the results."""
+        is_direction_ignored = arguments.get("isDirectionIgnored", True)
+        limit = arguments.get("limit", 10)
+
+        query = (
+            "CALL betweenness_centrality.get($directed, True) "
+            "YIELD node, betweenness_centrality "
+            "RETURN node, betweenness_centrality "
+            "ORDER BY betweenness_centrality DESC "
+            "LIMIT $limit"
+        )
+        params = {"directed": not is_direction_ignored, "limit": limit}
+
+        results = self.db.query(query, params)
+
+        # Convert the results to a list of dictionaries
+        return results

memgraph_toolbox/tools/config.py

@@ -0,0 +1,23 @@
+from typing import Any, Dict, List
+
+from ..api.memgraph import Memgraph
+from ..api.tool import BaseTool
+
+
+class ShowConfigTool(BaseTool):
+    """
+    Tool for showing configuration information from Memgraph.
+    """
+
+    def __init__(self, db: Memgraph):
+        super().__init__(
+            name="show_config",
+            description="Shows configuration information from a Memgraph database",
+            input_schema={"type": "object", "properties": {}, "required": []},
+        )
+        self.db = db
+
+    def call(self, arguments: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Execute the SHOW CONFIG query and return the results."""
+        config_info = self.db.query("SHOW CONFIG")
+        return config_info

memgraph_toolbox/tools/constraint.py

@@ -0,0 +1,23 @@
+from typing import Any, Dict, List
+
+from ..api.memgraph import Memgraph
+from ..api.tool import BaseTool
+
+
+class ShowConstraintInfoTool(BaseTool):
+    """
+    Tool for showing constraint information from Memgraph.
+    """
+
+    def __init__(self, db: Memgraph):
+        super().__init__(
+            name="show_constraint_info",
+            description="Shows constraint information from a Memgraph database",
+            input_schema={"type": "object", "properties": {}, "required": []},
+        )
+        self.db = db
+
+    def call(self, arguments: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Execute the SHOW CONSTRAINT INFO query and return the results."""
+        constraint_info = self.db.query("SHOW CONSTRAINT INFO")
+        return constraint_info

memgraph_toolbox/tools/cypher.py

@@ -0,0 +1,33 @@
+from typing import Any, Dict, List
+
+from ..api.memgraph import Memgraph
+from ..api.tool import BaseTool
+
+
+class CypherTool(BaseTool):
+    """
+    Tool for running arbitrary Cypher queries on Memgraph.
+    """
+
+    def __init__(self, db: Memgraph):
+        super().__init__(
+            name="run_cypher",
+            description="Executes a Cypher query on a Memgraph database",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "The Cypher query to execute",
+                    }
+                },
+                "required": ["query"],
+            },
+        )
+        self.db = db
+
+    def call(self, arguments: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Execute the provided Cypher query and return the results."""
+        query = arguments["query"]
+        result = self.db.query(query)
+        return [dict(record) for record in result]

memgraph_toolbox/tools/index.py

@@ -0,0 +1,23 @@
+from typing import Any, Dict, List
+
+from ..api.memgraph import Memgraph
+from ..api.tool import BaseTool
+
+
+class ShowIndexInfoTool(BaseTool):
+    """
+    Tool for showing index information in Memgraph.
+    """
+
+    def __init__(self, db: Memgraph):
+        super().__init__(
+            name="show_index_info",
+            description="Shows index information from a Memgraph database",
+            input_schema={"type": "object", "properties": {}, "required": []},
+        )
+        self.db = db
+
+    def call(self, arguments: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Execute the SHOW INDEX INFO query and return the results."""
+        index_info = self.db.query("SHOW INDEX INFO")
+        return index_info

memgraph_toolbox/tools/page_rank.py

@@ -0,0 +1,43 @@
+from typing import Any, Dict, List
+
+from ..api.memgraph import Memgraph
+from ..api.tool import BaseTool
+
+
+class PageRankTool(BaseTool):
+    """
+    Tool for calculating PageRank on a graph in Memgraph.
+    """
+
+    def __init__(self, db: Memgraph):
+        super().__init__(
+            name="pagerank",
+            description="Calculates PageRank on a graph in Memgraph",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "limit": {
+                        "type": "integer",
+                        "description": "Number of nodes to return ",
+                        "default": 10,
+                    },
+                },
+                "required": [],
+            },
+        )
+        self.db = db
+
+    # TODO:(@antejavor) This will fail if user is not running Memgraph Mage since memgraph does not have this built in.
+    def call(self, arguments: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Execute the PageRank algorithm and return the results."""
+        limit = arguments.get("limit", 20)
+
+        query = f"""
+            CALL pagerank.get()
+            YIELD node, rank
+            RETURN node, rank
+            ORDER BY rank DESC LIMIT {limit}
+            """
+        pagerank_results = self.db.query(query)
+
+        return pagerank_results

memgraph_toolbox/tools/schema.py

@@ -0,0 +1,22 @@
+from typing import Any, Dict, List
+
+from ..api.memgraph import Memgraph
+from ..api.tool import BaseTool
+
+
+class ShowSchemaInfoTool(BaseTool):
+    """
+    Tool for showing schema information from Memgraph.
+    """
+
+    def __init__(self, db: Memgraph):
+        super().__init__(
+            name="show_schema_info",
+            description="Shows schema information from a Memgraph database",
+            input_schema={"type": "object", "properties": {}, "required": []},
+        )
+        self.db = db
+
+    def call(self, arguments: Dict[str, Any]) -> List[Dict[str, Any]]:
+        schema_info = self.db.query("SHOW SCHEMA INFO")
+        return schema_info

memgraph_toolbox/tools/storage.py

@@ -0,0 +1,23 @@
+from typing import Any, Dict, List
+
+from ..api.memgraph import Memgraph
+from ..api.tool import BaseTool
+
+
+class ShowStorageInfoTool(BaseTool):
+    """
+    Tool for showing storage information from Memgraph.
+    """
+
+    def __init__(self, db: Memgraph):
+        super().__init__(
+            name="show_storage_info",
+            description="Shows storage information from a Memgraph database",
+            input_schema={"type": "object", "properties": {}, "required": []},
+        )
+        self.db = db
+
+    def call(self, arguments: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Execute the SHOW STORAGE INFO query and return the results."""
+        storage_info = self.db.query("SHOW STORAGE INFO")
+        return storage_info

memgraph_toolbox/tools/trigger.py

@@ -0,0 +1,23 @@
+from typing import Any, Dict, List
+
+from ..api.memgraph import Memgraph
+from ..api.tool import BaseTool
+
+
+class ShowTriggersTool(BaseTool):
+    """
+    Tool for showing trigger information from Memgraph.
+    """
+
+    def __init__(self, db: Memgraph):
+        super().__init__(
+            name="show_triggers",
+            description="Shows trigger information from a Memgraph database",
+            input_schema={"type": "object", "properties": {}, "required": []},
+        )
+        self.db = db
+
+    def call(self, arguments: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Execute the SHOW TRIGGERS query and return the results."""
+        trigger_info = self.db.query("SHOW TRIGGERS")
+        return trigger_info

memgraph_toolbox/utils/logging.py

@@ -0,0 +1,15 @@
+import logging
+
+
+def logger_init(name: str) -> logging.Logger:
+    """Set up a logger with a consistent configuration."""
+    logger = logging.getLogger(name)
+    if not logger.hasHandlers():
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        logger.setLevel(logging.INFO)
+    return logger

memgraph_toolbox-0.1.0.dist-info/METADATA

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: memgraph-toolbox
+Version: 0.1.0
+Summary: Memgraph toolbox library for Memgraph AI tools and utilities
+Author-email: antejavor <ante.javor@memgraph.io>
+License: MIT
+License-File: LICENSE
+Keywords: ai,graph,memgraph,toolkit
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.26.0; extra == 'test'
+Requires-Dist: pytest>=8.3.5; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Memgraph Toolbox
+
+The **Memgraph Toolbox** is a collection of tools designed to interact with a
+Memgraph database. These tools provide functionality for querying, analyzing,
+and managing data within Memgraph, making it easier to work with graph data.
+They are made to be easily called from other framework implementations such as
+**MCP**, **Langchain** or **Lamaindex**.
+
+## Available Tools
+
+Below is a list of tools included in the toolbox, along with their descriptions:
+
+1. `ShowTriggersTool` - Shows trigger information from a Memgraph database.
+2. `ShowStorageInfoTool` - Shows storage information from a Memgraph database.
+3. `ShowSchemaInfoTool` - Shows schema information from a Memgraph database.
+4. `PageRankTool` - Calculates PageRank on a graph in Memgraph.
+5. `ShowIndexInfoTool` - Shows index information from a Memgraph database.
+6. `CypherTool` - Executes arbitrary Cypher queries on a Memgraph database.
+7. `ShowConstraintInfoTool` - Shows constraint information from a Memgraph database.
+8. `ShowConfigTool` - Shows configuration information from a Memgraph database.
+9. `BetweennessCentralityTool` - Calculates betweenness centrality for nodes in a graph.
+
+## Usage
+
+Each tool is implemented as a Python class inheriting from `BaseTool`. To use a
+tool:
+
+1. Instantiate the tool with a `Memgraph` database connection.
+2. Call the `call` method with the required arguments.
+
+Example:
+
+```python
+from memgraph_toolbox.tools.trigger import ShowTriggersTool
+from memgraph_toolbox.api.memgraph import Memgraph
+
+# Connect to Memgraph
+db = Memgraph()
+
+# Use the ShowTriggersTool
+tool = ShowTriggersTool(db)
+triggers = tool.call({})
+print(triggers)
+```
+
+## Requirements
+
+- Python 3.10+
+- Memgraph database
+- Memgraph Mage (for certain tools like `pagerank` and `run_betweenness_centrality`)
+
+## Contributing
+
+Contributions are welcome! Feel free to submit issues or pull requests to
+improve the toolbox.
+
+## License
+
+This project is licensed under the MIT License. See the `LICENSE` file for
+details.

memgraph_toolbox-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+memgraph_toolbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+memgraph_toolbox/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+memgraph_toolbox/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+memgraph_toolbox/api/memgraph.py,sha256=YjEEvOr4-aY05GxQLmyNZUNnAU9z8yJw98GvI3FdICE,3272
+memgraph_toolbox/api/tool.py,sha256=SqOCivE2NsqUrcCFyDxPOdc5nJQoSCVFfN_79rGMgEA,1222
+memgraph_toolbox/api/toolkit.py,sha256=yF4FI56jpK6q1T9b3ObeO28brmuVsg4WXrWCPrngbI8,1072
+memgraph_toolbox/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+memgraph_toolbox/tests/test_toolkit.py,sha256=cJIyjSYf5Da1tEry1BNaggiiXwyfTCl2HIQ2a6sFKTQ,882
+memgraph_toolbox/tests/test_tools.py,sha256=IUiqf5k8MA8s5LUUHwnan7_htSMY1w3zrCKYMVc5BjQ,5363
+memgraph_toolbox/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+memgraph_toolbox/tools/betweenness_centrality.py,sha256=QJIOob8i3N1W9TC4Rdlzs2-ucvzW6jd7YE7LdyVTLK0,2149
+memgraph_toolbox/tools/config.py,sha256=J-41yKzygAVwolpi3jxqjHsGxANwPeWaNhrNgd2cpd0,725
+memgraph_toolbox/tools/constraint.py,sha256=Yeh466Xu0PChl1qCHMD44NkQkb8_ovU7Nff14fgT6P0,762
+memgraph_toolbox/tools/cypher.py,sha256=rJreW2_ePgMelNNgC-GIwITDSyy3-mxmHBACDou--Y8,1009
+memgraph_toolbox/tools/index.py,sha256=g95oD5Y2hHgpNreIaruGdcLAnyq9mUdhZe1xaVclHtg,720
+memgraph_toolbox/tools/page_rank.py,sha256=jb8KxDr9nR4rzfWrT79u80plCMAe2qDBFvWcEMsvlbw,1328
+memgraph_toolbox/tools/schema.py,sha256=k7fqwBdFi33SlPo4OmFthjgH1SJr5PPsrwgrqKMHMks,657
+memgraph_toolbox/tools/storage.py,sha256=1gp7fR7Rggf2ftAMqAtFGGTq4AG_gc-6vvwlkSY8Usg,738
+memgraph_toolbox/tools/trigger.py,sha256=gtUocBOYZsgzVqU0yYGbVUFE45d5f2YnPXjG3kC5PBQ,723
+memgraph_toolbox/utils/logging.py,sha256=Tvrtfwq4n9mkmyj4p0lJfOACIVZzWOddNvx376Ycm5Y,481
+memgraph_toolbox-0.1.0.dist-info/METADATA,sha256=TUyyE_S8PLVxGSqU3HCeo-WRcieXXrB_rG8W8O8ikBQ,2746
+memgraph_toolbox-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+memgraph_toolbox-0.1.0.dist-info/licenses/LICENSE,sha256=Zs4MZAXqusfO2KGQoAOuIqEUtojbyIYIkiJQ0BTt45o,1065
+memgraph_toolbox-0.1.0.dist-info/RECORD,,

memgraph_toolbox-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

memgraph_toolbox-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Memgraph
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.