demos/demos_databases_apis/memgraph/visualizing_iam_dataset.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tutorial: Visualizing Identity and Access Management data set with Memgraph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook showcases using Graphistry to visualize data in Memgraph for a sample dataset of a company's Identity and Access Management records. We'll demonstrate how Graphistry streamlines the visualization of Cypher queries, making it easier and more effective to analyze rich and potentially large data in Memgraph."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### About the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Identity and Access Management (IAM) outlines who can access what, why, and when. Each organization's unique identity and structure shape how access is managed, forming the company's IAM. If the current IAM system becomes slow and unresponsive – unable to handle changes in team roles and permissions – graph databases are a leading solution. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### About Graphistry\n",
    "\n",
    "[Graphistry](https://www.graphistry.com) is a visual graph AI platform featuring rich point-and-click visual analytics  and end-to-end GPU acceleration for exploring and analyzing many relationships. The OSS [PyGraphistry](https://github.com/graphistry/pygraphistry) library enables quickly visualizing large data from Memgraph, and provides a rich and easy dataframe-centric library for intermediate graph processing steps like data shaping, graph algorithms, graph layouts, autoML, autoAI, and data-driven visualization configuration. If you have a GPU where your PyGraphistry client is running, it supports automatic GPU acceleration for the locally executed steps. PyGraphistry is often used directly within data science notebooks and as a Python toolkit for building custom dashboards and webapps.\n",
    "\n",
    "#### About Memgraph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Memgraph](https://memgraph.com/) is an open-source, in-memory graph database. It is compatible with Neo4j's Bolt protocol and supports the widely used Cypher query language for interacting with the database. Cypher provides a powerful and expressive way to work with graph structures and perform various operations on the nodes and relationships within a graph database.\n",
    "\n",
    "A convenient entry point to kickstart your journey with Memgraph is through Docker. By simply entering the following command in your terminal, you can set up the Memgraph Platform within a Docker container:\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "docker run -it -p 7687:7687 -p 7444:7444 -p 3000:3000 -e MEMGRAPH=\" --bolt-server-name-for-init=Neo4j/\" memgraph/memgraph-platform "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If everything went well, after a couple of seconds you should see a message that Memgraph Lab is running at localhost:3000. You can access it through your web browser and start exploring !"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Configuration and installation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To begin, make sure to install the Graphistry Python client and the Neo4j Bolt drivers. You can achieve this by removing the comment symbol (#) from the first two lines in the provided code snippet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install --user graphistry\n",
    "#!pip install --user graphistry[bolt]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, import the necessary dependencies, including pandas, graphistry, and GraphDatabase. These libraries will be utilized to load and work with the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import graphistry\n",
    "from neo4j import GraphDatabase"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, establish a connection with your Graphistry GPU server account. Make sure to substitute the connection string and password with your personal credentials. You can create your account [here](https://www.graphistry.com/get-started). For additional configuration options, refer to [GitHub](https://github.com/graphistry/pygraphistry#configure)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To specify Graphistry account & server, use:\n",
    "# graphistry.register(api=3, username='...', password='...', protocol='https', server='hub.graphistry.com')\n",
    "# graphistry.register(..., personal_key_id='pkey_id', personal_key_secret='pkey_secret') # Key instead of username+password+org_name"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Connecting to Graphistry and Memgraph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll establish a connection to a Memgraph database using the Bolt protocol. The Bolt protocol is a binary communication protocol that facilitates interaction between the Python code and the Memgraph database.\n",
    "\n",
    "The URI includes the hostname (localhost) and the port number (7687) where the Memgraph database is listening for Bolt connections. The authentication part includes a tuple with the username and the password that you would use to authenticate and gain access to the Memgraph database. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "MEMGRAPH = {\n",
    "    'uri': \"bolt://localhost:7687\", \n",
    "    'auth': (\" \", \" \")\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After that, we can use the Graphistry library to register a connection to a database using the Bolt protocol and the provided configuration.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "graphistry.register(bolt=MEMGRAPH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Uploading the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now initialize a Memgraph driver instance. Following this, we'll be able to utilize the session.run() method to execute Cypher queries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "driver = GraphDatabase.driver(**MEMGRAPH)\n",
    "\n",
    "with driver.session() as session:      \n",
    "    session.run(\"\"\" CREATE (per1:Person {id: 1, name: \"Julie\"})\n",
    "CREATE (per2:Person {id: 2, name: \"Peter\"})\n",
    "CREATE (per3:Person {id: 3, name: \"Anna\"})\n",
    "CREATE (per4:Person {id: 4, name: \"Carl\"})\n",
    "CREATE (tea1:Team {id: 1, name: \"Engineering\"})\n",
    "CREATE (tea2:Team {id: 2, name: \"Operations\"})\n",
    "CREATE (tea3:Team {id: 3, name: \"Marketing\"})\n",
    "CREATE (rep1:Repository {id: 1, name: \"Memgraph\"})\n",
    "CREATE (rep2:Repository {id: 2, name: \"MAGE\"})\n",
    "CREATE (rep3:Repository {id: 3, name: \"Marketing\"})\n",
    "CREATE (com1:Company {id: 1, name: \"Memgraph\"})\n",
    "CREATE (sto1:Storage {id: 1, name: \"Google Drive\"})\n",
    "CREATE (sto2:Storage {id: 2, name: \"Notion\"})\n",
    "CREATE (fol1:Folder {id: 1, name: \"engineering_folder\"})\n",
    "CREATE (fol2:Folder {id: 2, name: \"operations_folder\"})\n",
    "CREATE (acc1:Account {id: 1, name: \"Facebook\"})\n",
    "CREATE (acc2:Account {id: 2, name: \"LinkedIn\"})\n",
    "CREATE (acc3:Account {id: 3, name: \"HackerNews\"}) \n",
    "CREATE (fil1:File {id: 1, name: \"welcome_to_engineering.txt\"})\n",
    "CREATE (fil2:File {id: 2, name: \"welcome_to_memgraph.txt\"})\n",
    "CREATE (fil3:File {id: 3, name: \"operations101.txt\"})\n",
    "CREATE (fil4:File {id: 4, name: \"expenses2022.csv\"})\n",
    "CREATE (fil5:File {id: 5, name: \"salaries2022.csv\"})\n",
    "CREATE (fil6:File {id: 6, name: \"engineering101.txt\"})\n",
    "CREATE (fil7:File {id: 7, name: \"working_with_github.txt\"})\n",
    "CREATE (fil8:File {id: 8, name: \"working_with_notion.txt\"})\n",
    "CREATE (fil9:File {id: 9, name: \"welcome_to_marketing.txt\"})\n",
    "CREATE (per1)-[:HAS_ACCESS_TO]->(fil2)\n",
    "CREATE (per2)-[:HAS_ACCESS_TO]->(fil2)               \n",
    "CREATE (per2)-[:IS_PART_OF]->(tea1)\n",
    "CREATE (per2)-[:IS_PART_OF]->(com1)\n",
    "CREATE (per2)-[:IS_PART_OF]->(tea2)\n",
    "CREATE (per3)-[:IS_PART_OF]->(tea2)\n",
    "CREATE (per3)-[:IS_PART_OF]->(tea3)\n",
    "CREATE (per3)-[:IS_PART_OF]->(com1)\n",
    "CREATE (per4)-[:IS_PART_OF]->(tea1)\n",
    "CREATE (per4)-[:IS_PART_OF]->(com1)\n",
    "CREATE (per4)-[:HAS_ACCESS_TO]->(fil2)\n",
    "CREATE (com1)-[:HAS_TEAM]->(tea1)\n",
    "CREATE (com1)-[:HAS_TEAM]->(tea3)\n",
    "CREATE (com1)-[:HAS_TEAM]->(tea2)\n",
    "CREATE (fil1)-[:IS_STORED_IN]->(sto1)\n",
    "CREATE (fil1)-[:IS_STORED_IN]->(sto2)\n",
    "CREATE (fol2)-[:IS_STORED_IN]->(sto1)\n",
    "CREATE (fil9)-[:IS_STORED_IN]->(sto1)\n",
    "CREATE (fil9)-[:IS_STORED_IN]->(sto2)\n",
    "CREATE (fol1)-[:IS_STORED_IN]->(sto1)\n",
    "CREATE (fil2)-[:CREATED_BY]->(per3)\n",
    "CREATE (fol1)-[:HAS_ACCESS_TO]->(fil6)\n",
    "CREATE (fol1)-[:HAS_ACCESS_TO]->(fil7)\n",
    "CREATE (fol1)-[:HAS_ACCESS_TO]->(fil8)\n",
    "CREATE (fol2)-[:HAS_ACCESS_TO]->(fil3)\n",
    "CREATE (fol2)-[:HAS_ACCESS_TO]->(fil4)\n",
    "CREATE (fol2)-[:HAS_ACCESS_TO]->(fil5)\n",
    "CREATE (tea2)-[:HAS_ACCESS_TO]->(fol2)\n",
    "CREATE (rep3)-[:HAS_ACCESS_TO]->(acc1)\n",
    "CREATE (rep3)-[:HAS_ACCESS_TO]->(acc2)\n",
    "CREATE (rep3)-[:HAS_ACCESS_TO]->(acc3)\n",
    "CREATE (rep3)-[:HAS_ACCESS_TO]->(fil9)\n",
    "CREATE (tea1)-[:HAS_ACCESS_TO]->(rep1)\n",
    "CREATE (tea1)-[:HAS_ACCESS_TO]->(rep2)\n",
    "CREATE (tea1)-[:HAS_ACCESS_TO]->(rep3)\n",
    "CREATE (tea1)-[:HAS_ACCESS_TO]->(fil1)\n",
    "CREATE (tea1)-[:HAS_ACCESS_TO]->(fol1)\n",
    "                \"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = graphistry.cypher(\"\"\" MATCH (node1)-[connection]-(node2) RETURN node1, connection, node2;\n",
    "  \"\"\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualization of the data \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After populating your Memgraph instance, it's time to visualize the dataset with Graphistry. But first, let's see the graph schema in Memgraph Lab. It defines the structure of your data and its relationships, providing a blueprint for how your data elements are connected and organized within the graph database and  offers interactive graph visualizations.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Screenshot](https://github.com/karmenrabar/pygraphistry_images/blob/main/memgraphlab.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotting with grapistry is done by the following simple command:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "            <iframe id=\"b1bbd88f-869b-4953-92b9-711d48858e13\" src=\"https://hub.graphistry.com/graph/graph.html?dataset=42d427f14b064400bc85c8e04591d110&type=arrow&viztoken=65c284ba-ef61-4931-9368-79e0d7710ce2&usertag=f21ede7a-pygraphistry-0.29.3&splashAfter=1693500521&info=true\"\n",
       "                    allowfullscreen=\"true\" webkitallowfullscreen=\"true\" mozallowfullscreen=\"true\"\n",
       "                    oallowfullscreen=\"true\" msallowfullscreen=\"true\"\n",
       "                    style=\"width:100%; height:500px; border: 1px solid #DDD; overflow: hidden\"\n",
       "                    \n",
       "            >\n",
       "            </iframe>\n",
       "        \n",
       "            <script>\n",
       "                try {\n",
       "                  $(\"#b1bbd88f-869b-4953-92b9-711d48858e13\").bind('mousewheel', function(e) { e.preventDefault(); });\n",
       "                } catch (e) { console.error('exn catching scroll', e); }\n",
       "            </script>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Screenshot:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Screenshot](https://github.com/karmenrabar/pygraphistry_images/blob/main/allaccess.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can easily investigate which files Carl has access to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "            <iframe id=\"693c1860-4eea-40a2-8984-f56ea4baaab8\" src=\"https://hub.graphistry.com/graph/graph.html?dataset=7eb6acacebd44ea397698e127d6137ea&type=arrow&viztoken=ce266113-a7e7-40ec-a002-808995ff132f&usertag=f21ede7a-pygraphistry-0.29.3&splashAfter=1693500524&info=true\"\n",
       "                    allowfullscreen=\"true\" webkitallowfullscreen=\"true\" mozallowfullscreen=\"true\"\n",
       "                    oallowfullscreen=\"true\" msallowfullscreen=\"true\"\n",
       "                    style=\"width:100%; height:500px; border: 1px solid #DDD; overflow: hidden\"\n",
       "                    \n",
       "            >\n",
       "            </iframe>\n",
       "        \n",
       "            <script>\n",
       "                try {\n",
       "                  $(\"#693c1860-4eea-40a2-8984-f56ea4baaab8\").bind('mousewheel', function(e) { e.preventDefault(); });\n",
       "                } catch (e) { console.error('exn catching scroll', e); }\n",
       "            </script>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "direct_file_access_Carl = graphistry.cypher(\"\"\"  MATCH (j:Person {name:\"Carl\"})-[r:HAS_ACCESS_TO]->(n)\n",
    "RETURN *;  \"\"\")\n",
    "direct_file_access_Carl.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Screenshot:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Screenshot](https://github.com/karmenrabar/pygraphistry_images/blob/main/access3.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Carl has direct access to a file. But, Since Team nodes have access to specific folders, if Carl is a part of a team, he indirectly has access to all files in that folder. With the next query we can see how a depth-first search is performed from a node with the label Person with the name Carl to the node with the label File. It finds a path from Carl to a file directly or through other nodes. The symbol * represents depth-first search and the number 3 is a maximum depth (maximum number of jumps)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "            <iframe id=\"0eec7023-c354-4d9d-af54-8df9fe448e6a\" src=\"https://hub.graphistry.com/graph/graph.html?dataset=909e17d9a9f543178a5d6ee9870402a9&type=arrow&viztoken=c80272e8-a720-4111-9c79-a2128e56430c&usertag=f21ede7a-pygraphistry-0.29.3&splashAfter=1693500527&info=true\"\n",
       "                    allowfullscreen=\"true\" webkitallowfullscreen=\"true\" mozallowfullscreen=\"true\"\n",
       "                    oallowfullscreen=\"true\" msallowfullscreen=\"true\"\n",
       "                    style=\"width:100%; height:500px; border: 1px solid #DDD; overflow: hidden\"\n",
       "                    \n",
       "            >\n",
       "            </iframe>\n",
       "        \n",
       "            <script>\n",
       "                try {\n",
       "                  $(\"#0eec7023-c354-4d9d-af54-8df9fe448e6a\").bind('mousewheel', function(e) { e.preventDefault(); });\n",
       "                } catch (e) { console.error('exn catching scroll', e); }\n",
       "            </script>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_file_access_Carl = graphistry.cypher(\"\"\"\n",
    "MATCH p=(:Person {name:\"Carl\"})-[* ..3]->(:File)\n",
    "RETURN p;\n",
    " \"\"\")\n",
    "all_file_access_Carl.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Screenshot:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Screenshot](https://github.com/karmenrabar/pygraphistry_images/blob/main/access2.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can also be done for all Person nodes with executing the following query. This is an example why graph databases are great for Identity and Access Management."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "            <iframe id=\"12062a9b-b4fa-4ad1-8553-e3eb2af78169\" src=\"https://hub.graphistry.com/graph/graph.html?dataset=6fda75d4cb72490d8fb0db7908bd0a9d&type=arrow&viztoken=d9a8080d-6f32-4531-ada8-201c79d0d2bb&usertag=f21ede7a-pygraphistry-0.29.3&splashAfter=1693500530&info=true\"\n",
       "                    allowfullscreen=\"true\" webkitallowfullscreen=\"true\" mozallowfullscreen=\"true\"\n",
       "                    oallowfullscreen=\"true\" msallowfullscreen=\"true\"\n",
       "                    style=\"width:100%; height:500px; border: 1px solid #DDD; overflow: hidden\"\n",
       "                    \n",
       "            >\n",
       "            </iframe>\n",
       "        \n",
       "            <script>\n",
       "                try {\n",
       "                  $(\"#12062a9b-b4fa-4ad1-8553-e3eb2af78169\").bind('mousewheel', function(e) { e.preventDefault(); });\n",
       "                } catch (e) { console.error('exn catching scroll', e); }\n",
       "            </script>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_file_access = graphistry.cypher(\"\"\"\n",
    "MATCH p=(:Person)-[* ..3]->(:File)\n",
    "RETURN p;\n",
    " \"\"\")\n",
    "all_file_access.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Screenshot:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Screenshot](https://github.com/karmenrabar/pygraphistry_images/blob/main/access.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Takeaway and further reading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "PyGraphistry complements Memgraph by providing a specialized tool for creating rich and interactive visualizations of graph data stored in Memgraph. It allows users to gain deeper insights into their graph data by leveraging the advanced visualization capabilities of the Graphistry platform, especially when dealing with complex and extensive graph data sets.\n",
    "\n",
    "Feel free to get your hands on Graphistry and Memgraph and share your insights or questions with us on the [Memgraph Discord](https://discord.com/invite/memgraph) and [Graphistry community Slack](https://join.slack.com/t/graphistry-community/shared_invite/zt-53ik36w2-fpP0Ibjbk7IJuVFIRSnr6g)!\n",
    "\n",
    "You can find out more about building and scaling modern IAM systems with Memgraph [here](https://memgraph.com/identity-access-management?utm_source=memgraph&utm_medium=referral&utm_campaign=bfb_blog&utm_content=iam) and on blogposts [What Makes Memgraph Great for Real-Time Performance in IAM Systems](https://memgraph.com/blog/what-makes-memgraph-great-for-real-time-performance-in-iam-systems), [Benefits Graph Databases Bring to Identity and Access Management](https://memgraph.com/blog/benefits-graph-databases-bring-to-identity-and-access-management) and [How Graphs Solve Two Biggest Problems of Traditional IAM Systems](https://memgraph.com/blog/how-graphs-solves-two-biggest-problems-of-traditional-iam-systems).\n",
    "\n",
    "The [PyGraphistry README.md](https://github.com/graphistry/pygraphistry) shares examples for how to take your Memgraph query result and perform on-the-fly steps like filtering, Pandas dataframe analysis, graph algorithm enrichments, autoML & autoAI analysis, new layouts, and configuring data-driven visualizations. The [PyGraphistry demos folder](https://github.com/graphistry/pygraphistry/tree/master/demos) has more examples of how security operations and security data science teams are using Graphistry, including a free [GPU graph visualization & AI security analytics training from Nvidia GTC 2022](https://www.nvidia.com/en-us/on-demand/session/gtcspring23-dlit51954/). You may also want to explore how [Louie.AI](https://www.louie.ai) is enabling analyst teams to talk directly to their data silos in natural language and get back analyses and visualizations, including Graphistry graph and AI visualizations. Finally, you may consider [graph-app-kit](https://github.com/graphistry/graph-app-kit) as a maintained OSS Streamlit distribution and reference for building PyData dashboards with Graphistry and your Memgraph data.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "vsc",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}