memgraph-toolbox 0.1.0__tar.gz

memgraph_toolbox-0.1.0/.gitignore

@@ -0,0 +1,174 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc

memgraph_toolbox-0.1.0/.python-version

@@ -0,0 +1 @@
+3.10

memgraph_toolbox-0.1.0/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.

memgraph_toolbox-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,60 @@
+# 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/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "memgraph-toolbox"
+version = "0.1.0"
+description = "Memgraph toolbox library for Memgraph AI tools and utilities"
+readme = "README.md"
+authors = [
+  { name = "antejavor", email = "ante.javor@memgraph.io" }
+]
+license = { text = "MIT" }
+requires-python = ">=3.10"
+url = "https://github.com/memgraph/ai-toolkit"
+
+keywords = ["memgraph", "graph", "ai", "toolkit"]
+
+classifiers = [
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+]
+
+[project.optional-dependencies]
+test = [
+  "pytest>=8.3.5",
+  "pytest-asyncio>=0.26.0",
+]
+
+[build-system]
+requires = ["hatchling", "build"]
+build-backend = "hatchling.build"
+
+[tool.pytest.ini_options]
+log_cli = true
+log_cli_level = "INFO"

memgraph_toolbox-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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/uv.lock

@@ -0,0 +1,84 @@
+version = 1
+revision = 1
+requires-python = ">=3.13"
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
+]
+
+[[package]]
+name = "core"
+version = "0.1.0"
+source = { editable = "." }
+
+[package.optional-dependencies]
+test = [
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "pytest", marker = "extra == 'test'", specifier = ">=8.3.5" },
+    { name = "pytest-asyncio", marker = "extra == 'test'", specifier = ">=0.26.0" },
+]
+provides-extras = ["test"]
+
+[[package]]
+name = "iniconfig"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050 },
+]
+
+[[package]]
+name = "packaging"
+version = "24.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 },
+]
+
+[[package]]
+name = "pytest"
+version = "8.3.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ae/3c/c9d525a414d506893f0cd8a8d0de7706446213181570cdbd766691164e40/pytest-8.3.5.tar.gz", hash = "sha256:f4efe70cc14e511565ac476b57c279e12a855b11f48f212af1080ef2263d3845", size = 1450891 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/30/3d/64ad57c803f1fa1e963a7946b6e0fea4a70df53c1a7fed304586539c2bac/pytest-8.3.5-py3-none-any.whl", hash = "sha256:c69214aa47deac29fad6c2a4f590b9c4a9fdb16a403176fe154b79c0b4d4d820", size = 343634 },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "0.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8e/c4/453c52c659521066969523e87d85d54139bbd17b78f09532fb8eb8cdb58e/pytest_asyncio-0.26.0.tar.gz", hash = "sha256:c4df2a697648241ff39e7f0e4a73050b03f123f760673956cf0d72a4990e312f", size = 54156 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/7f/338843f449ace853647ace35870874f69a764d251872ed1b4de9f234822c/pytest_asyncio-0.26.0-py3-none-any.whl", hash = "sha256:7b51ed894f4fbea1340262bdae5135797ebbe21d8638978e35d31c6d19f72fb0", size = 19694 },
+]