Memgraph

https://memgraph.com/docs
Admin
Memgraph is an open-source graph database built for streaming and compatible with Neo4j, designed...
Tokens:733,024
Snippets:10,140
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Setup the Neo4j GraphQL Library

Source: https://memgraph.com/docs/client-libraries/graphql

Installs the Neo4j GraphQL Library, its dependencies, and Apollo Server.

```bash
npm install @neo4j/graphql@7.2.0 graphql neo4j-driver @apollo/server
```

--------------------------------

### Example download and install command

Source: https://memgraph.com/docs/getting-started/install-memgraph/wsl

This is an example of the download and install command using a specific version.

```bash
wget https://download.memgraph.com/memgraph/v2.17.0/ubuntu-22.04/memgraph_2.17.0-1_amd64.deb -O memgraph.deb 
sudo dpkg -i memgraph.deb
```

--------------------------------

### Configure composer.json

Source: https://memgraph.com/docs/client-libraries/php

Example configuration for composer.json including a start script.

```json
{
    "require": {
        "stefanak-michal/bolt": "^7"
    }, 
    "scripts": {
        "start": "php -S localhost:4000"
    },
    "config": {
        "allow-plugins": {
            "php-http/discovery": true
        }
    }
}
```

--------------------------------

### Example GraphQL Query

Source: https://memgraph.com/docs/client-libraries/graphql

An example GraphQL query to interact with Memgraph.

```graphql
query Users {
  users {
    name
    posts {
      content
    }
  }
}

```

--------------------------------

### View installation path

Source: https://memgraph.com/docs/getting-started

Example output showing the location where the Docker Compose file is downloaded.

```text
-e Downloading docker compose file to: /Users/katelatte/memgraph-platform/docker-compose.yml
```

--------------------------------

### Set up your script

Source: https://memgraph.com/docs/client-libraries/nodejs

Install _Express.js_ and the _Bolt driver_ in the `/MyApp` directory while adding them to the dependencies list:

```bash
npm install express --save
npm install neo4j-driver --save
```

--------------------------------

### Run Memgraph

Source: https://memgraph.com/docs/client-libraries/graphql

Command to install and run Memgraph Platform on Windows.

```powershell
iwr https://windows.memgraph.com | iex
```

--------------------------------

### Example Database State Setup

Source: https://memgraph.com/docs/advanced-algorithms/available-algorithms/do

Cypher queries to set up the initial database state for the example.

```cypher
MERGE (a:Node {id: 0}) MERGE (b:Node {id: 1}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 1}) MERGE (b:Node {id: 2}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 0}) MERGE (b:Node {id: 2}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 3}) MERGE (b:Node {id: 4}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 3}) MERGE (b:Node {id: 5}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 4}) MERGE (b:Node {id: 5}) CREATE (a)-[:RELATION]->(b);
```

--------------------------------

### Start Ubuntu

Source: https://memgraph.com/docs/getting-started/install-memgraph/wsl

Run the command below from PowerShell to launch Ubuntu.

```bash
ubuntu
```

--------------------------------

### Install Memgraph Platform via script

Source: https://memgraph.com/docs/getting-started

Execute the installation script for your operating system to download and start the Memgraph Platform services.

```bash
curl https://install.memgraph.com | sh
```

```powershell
iwr https://windows.memgraph.com | iex
```

--------------------------------

### Run Memgraph

Source: https://memgraph.com/docs/client-libraries/graphql

Command to install and run Memgraph Platform on Linux and macOS.

```bash
curl https://install.memgraph.com | sh
```

--------------------------------

### Configure Multi-tenant Environment Roles and Permissions

Source: https://memgraph.com/docs/configuration/security

Example setup for creating tenant-specific roles, granting database access, and assigning roles to users.

```Cypher
-- Create tenant-specific roles
CREATE ROLE tenant1_user;
CREATE ROLE tenant2_user;
 
-- Grant appropriate permissions to tenant roles
GRANT MATCH, CREATE, MERGE, SET, DELETE TO tenant1_user;
GRANT MATCH, CREATE, MERGE, SET, DELETE TO tenant2_user;
 
-- Grant access to tenant databases only
GRANT DATABASE tenant1_db TO tenant1_user;
GRANT DATABASE tenant2_db TO tenant2_user;
 
-- Create users
-- On Enterprise, the first user is automatically assigned the built-in admin role
CREATE USER admin_user IDENTIFIED BY 'admin_password';
CREATE USER tenant1_user_account IDENTIFIED BY 'password1';
CREATE USER tenant2_user_account IDENTIFIED BY 'password2';
 
-- Assign roles to tenant users
SET ROLE FOR tenant1_user_account TO tenant1_user;
SET ROLE FOR tenant2_user_account TO tenant2_user;
```

--------------------------------

### Example Dockerfile for Memgraph Lab with custom SSL

Source: https://memgraph.com/docs/data-visualization/user-manual/custom-base-path

Dockerfile example for running Memgraph Lab with custom SSL certificates enabled and paths configured.

```dockerfile
FROM memgraph/lab:latest
 
# Environment variables
ENV SSL_IS_ENABLED=true
ENV SSL_CERT_PATH=./myssl/cert.pem
ENV SSL_KEY_PATH=./myssl/key.pem
 
```

--------------------------------

### Run Memgraph Docker container

Source: https://memgraph.com/docs/release-notes

Example command for starting a Memgraph Docker container.

```bash
docker run -it memgraph/memgraph:3.10.0
```

--------------------------------

### Full Configuration File Example

Source: https://memgraph.com/docs/memgraph-lab/features/custom-configuration

A comprehensive example demonstrating both settings and feature visibility configurations.

```yaml
version: 1
settings:
  application:
    theme:
      value: dark
      isLocked: true
  runHistory:
    maxRecordCount:
      value: 100
      isLocked: false
  monitoring:
    pollingIntervalSec:
      value: 20
 
features:
- name: tabs.system.configure
  items:
  - id: datasets
    isHidden: true
  - id: streams
    isHidden: true
 
- name: graph.nodes.system.configure
  items:
  - id: collapse
    isHidden: true
  - id: hide
    isHidden: true
  - id: remove
    isHidden: true
```

--------------------------------

### Set up your script

Source: https://memgraph.com/docs/client-libraries/nodejs

Initialize your project and create a `package.json` file with the command:

```bash
npm init
```

--------------------------------

### Registering a Read Procedure

Source: https://memgraph.com/docs/custom-query-modules/cpp/cpp-example

Example of registering a read procedure named 'get' using the AddProcedure function. This procedure takes a start node and length, and returns a Path.

```cpp
extern "C" int mgp_init_module(struct mgp_module *module, struct mgp_memory *memory) {
  try {
    mgp::MemoryDispatcherGuard guard(memory);
 
    AddProcedure(RandomWalk, "get", mgp::ProcedureType::Read,
                 {mgp::Parameter("start", mgp::Type::Node), mgp::Parameter("length", mgp::Type::Int)},
                 {mgp::Return("random_walk", mgp::Type::Path)}, module, memory);
  } catch (const std::exception &e) {
    return 1;
  }
  return 0;
}
```

--------------------------------

### DFS Pre-order Nodes Usage

Source: https://memgraph.com/docs/advanced-algorithms/available-algorithms/nxalg

Example Cypher query to get nodes in a depth-first-search pre-ordering starting from a source node with a specified depth limit.

```cypher
MATCH (source:Label)
CALL nxalg.dfs_preorder_nodes(source, 10) 
YIELD nodes
RETURN source, nodes AS preoder_nodes;
```

--------------------------------

### Set up your script

Source: https://memgraph.com/docs/client-libraries/nodejs

To make the actual program, create an `example.js` file and add the following code:

```javascript
  const express = require("express");
  const app = express();
  const port = 3000;
  var db = require("neo4j-driver");
  app.get("/", async (req, res) => {
    const driver = db.driver("bolt://localhost:7687");
    const session = driver.session();
    try {
      const result = await session.executeWrite((tx) =>
        tx.run(
          'CREATE (a:Greeting) SET a.message = $message RETURN "Node " + id(a) + ": " + a.message',
          {
            message: "Hello, World!",
          }
        )
      );
  
      const singleRecord = result.records[0];
      const greeting = singleRecord.get(0);
  
      console.log(greeting); 
 
      res.send("Welcome to Node.js quick start guide!")
    } finally {
      await session.close();
    }
  
    // On application exit:
    await driver.close();
  });
  
  app.listen(port, () => {
    console.log(`Example app listening at http://localhost:${port}`);
  });
```

--------------------------------

### Dockerfile Example

Source: https://memgraph.com/docs/data-visualization/user-manual/custom-base-path

This snippet shows how to copy SSL certificates into the Docker image and expose the default port.

```dockerfile
COPY ssl/ ./myssl/

EXPOSE 3000
```

--------------------------------

### Set up your script

Source: https://memgraph.com/docs/client-libraries/nodejs

Create a new directory for your application and position yourself in it.

```bash
mkdir MyApp
cd MyApp
```

--------------------------------

### Install the Memgraph package (Ubuntu 24.04 example)

Source: https://memgraph.com/docs/getting-started/packaging-memgraph

Example command to install the Memgraph package using apt on Ubuntu 24.04.

```bash
sudo apt install ./output/memgraph_<version>_<arch>.deb
```

--------------------------------

### Set up the toolchain

Source: https://memgraph.com/docs/advanced-algorithms/install-mage

Downloads and installs the required Memgraph toolchain and its runtime dependencies.

```bash
curl -L https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v7/toolchain-v7-binaries-ubuntu-24.04-amd64.tar.gz -o toolchain.tar.gz
sudo tar xzvfm toolchain.tar.gz -C /opt
```

```bash
sudo ./environment/os/install_deps.sh install TOOLCHAIN_RUN_DEPS
```

--------------------------------

### Get transaction start timestamp

Source: https://memgraph.com/docs/custom-query-modules/c/c-api

Retrieves the stable starting timestamp of the current transaction.

```c
enum mgp_error mgp_graph_get_start_timestamp(
    struct mgp_graph * graph,
    int64_t * result
)
```

--------------------------------

### Get Transaction Start Timestamp

Source: https://memgraph.com/docs/custom-query-modules/python/python-api

Returns the stable starting timestamp of the current transaction.

```python
@property
def start_timestamp() -> int
```

```python
graph.start_timestamp
```

--------------------------------

### TTL Setup Examples

Source: https://memgraph.com/docs/querying/time-to-live

Examples demonstrating how to set up TTL with different periods and times.

```cypher
# Run TTL every dat at 14:30 (will run immediately once if started after 14:30)
ENABLE TTL AT "14:30:00";
# Run TTL every 2nd day at 4:00 (will run immediately once if started after 4:00)
ENABLE TTL EVERY "2d" AT "04:00:00";
# Run TTL every 3 hours, starting from 19:45 today (will run immediately once if started after 19:45)
ENABLE TTL EVERY "3h" AT "19:45:00";
```

--------------------------------

### Create index.js file

Source: https://memgraph.com/docs/client-libraries/graphql

Sets up the Neo4j GraphQL Library and connects to the Memgraph instance.

```bash
touch index.js
```

```javascript
import { Neo4jGraphQL } from "@neo4j/graphql";
import { ApolloServer } from '@apollo/server'
import { startStandaloneServer } from '@apollo/server/standalone';
import neo4j from 'neo4j-driver'

const typeDefs = `
type Post @node {
    id: ID! @id
    content: String!
    creator: [User!]! @relationship(type: "HAS_POST", direction: IN)
}

type User @node {
    id: ID! @id
    name: String
    posts: [Post!]! @relationship(type: "HAS_POST", direction: OUT)
}
`;

const driver = neo4j.driver(
    "bolt://localhost:7687",
    neo4j.auth.basic("", "")
);

const neoSchema = new Neo4jGraphQL({ typeDefs, driver });

const server = new ApolloServer({
    schema: await neoSchema.getSchema(),
});

const { url } = await startStandaloneServer(server, {
    context: async ({ req }) => ({
        req,
        sessionConfig: { database: "memgraph" },
        cypherQueryOptions: { addVersionPrefix: false }
    }),
    listen: { port: 4000 },
});

console.log(`🚀 Server ready at ${url}`);

```

--------------------------------

### Get Vehicle Route Example

Source: https://memgraph.com/docs/advanced-algorithms/available-algorithms/vrp

Cypher query to get and visualize the vehicle route.

```Cypher
MATCH (d:Depot)
CALL vrp.route(d) 
YIELD from_vertex, to_vertex, vehicle_id
CREATE (from_vertex)-[r:Route]->(to_vertex);
 
MATCH (n)-[r:Route]->(m)
RETURN n, r, m;
```

--------------------------------

### Run the application

Source: https://memgraph.com/docs/client-libraries/graphql

Command to execute the application file.

```bash
node index.js
```

--------------------------------

### Enable Memgraph to start on boot

Source: https://memgraph.com/docs/getting-started/install-memgraph/centos

Command to configure Memgraph to start automatically on system startup.

```bash
systemctl enable memgraph
```

--------------------------------

### String operator example

Source: https://memgraph.com/docs/querying/expressions

Example of using the STARTS WITH string operator to filter nodes by name.

```cypher
MATCH (p:Person)
WHERE p.name STARTS WITH 'Joh'
RETURN p.name;
```

--------------------------------

### Explicit Transaction Example

Source: https://memgraph.com/docs/client-libraries/nodejs

An example of setting up an explicit transaction with a specified database.

```javascript
let session = driver.session({ database: 'neo4j' })
let transaction = await session.beginTransaction()
 
// await transaction.run('<QUERY 1>')
// await transaction.run('<QUERY 2>')
// ...
 
await transaction.close()
await session.close()

```

--------------------------------

### Create project directory

Source: https://memgraph.com/docs/memgraph-zero/memgql/use-cases/public-private

Initializes a new directory for the project and navigates into it.

```bash
mkdir public-private && cd public-private
```

--------------------------------

### Example GraphQL Query Result

Source: https://memgraph.com/docs/client-libraries/graphql

The expected result from the example GraphQL query.

```json
{
  "data": {
    "users": [
      {
        "name": "Alice",
        "posts": [
          {
            "content": "Alice's first post!"
          },
          {
            "content": "Another thought from Alice."
          }
        ]
      },
      {
        "name": "Bob",
        "posts": [
          {
            "content": "Bob's great idea."
          }
        ]
      }
    ]
  }
}

```

--------------------------------

### Create a work directory

Source: https://memgraph.com/docs/client-libraries/graphql

Creates a directory for the project and navigates into it.

```bash
mkdir graphql-example
cd graphql-example
```

--------------------------------

### Next function example

Source: https://memgraph.com/docs/data-visualization/graph-style-script/built-in-elements

Example demonstrating the Next function to get the next item from an iterator.

```gss
Next(AsIterator(AsArray(3, 2, 1)))
```

--------------------------------

### Uniq function examples

Source: https://memgraph.com/docs/data-visualization/graph-style-script/built-in-elements

Examples demonstrating the Uniq function to get unique elements from an array.

```gss
Uniq(AsArray(2,1,1,2,1,3,1))
```

```gss
Uniq(AsArray("1", "1", 1, True, True, 1))
```

--------------------------------

### Initialize the Node.js project

Source: https://memgraph.com/docs/client-libraries/graphql

Initializes a new Node.js project with ES6 modules.

```bash
npm init es6 --yes
```

--------------------------------

### Install hotspot GUI tool

Source: https://memgraph.com/docs/database-management/debugging

Install the hotspot tool on the host machine to visualize performance data.

```bash
apt install hotspot
```

--------------------------------

### Start Memgraph explicitly

Source: https://memgraph.com/docs/getting-started/install-memgraph/wsl

If the Memgraph database instance is not running, you can start it explicitly using this command.

```bash
sudo runuser -l memgraph -c '/usr/lib/memgraph/memgraph'
```

--------------------------------

### Compare docker run and docker start syntax

Source: https://memgraph.com/docs/getting-started/first-steps-with-docker

General syntax for creating new containers versus restarting existing ones.

```bash
docker run [OPTIONS] IMAGE [COMMAND]
```

```bash
docker start <CONTAINER_ID or NAME>
```

--------------------------------

### Size function example

Source: https://memgraph.com/docs/data-visualization/graph-style-script/built-in-elements

Example of using the Size function to get the length of a node's property.

```GSS
Size(Property(node, "name"))
```

--------------------------------

### Start MemGQL Container

Source: https://memgraph.com/docs/memgraph-zero/memgql/connect/iceberg

Launches the MemGQL service configured to connect to the Trino instance.

```bash
docker run --rm \
    --name memgql \
    --network memgql-net \
    --stop-timeout 2 \
    -p 7688:7688 \
    --env CONNECTOR_TYPE=iceberg \
    --env TRINO_URL=http://trino-dev:8080 \
    --env TRINO_CATALOG=iceberg \
    --env TRINO_SCHEMA=default \
    --env MAPPING_FILE=/data/mapping.json \
    --env BOLT_LISTEN_ADDR=0.0.0.0:7688 \
    -v ./mapping.json:/data/mapping.json \
    memgraph/memgql:latest
```

--------------------------------

### Provide Additional Configuration File via Docker

Source: https://memgraph.com/docs/configuration/configuration-settings

Steps to create a container, copy a custom configuration file, and start the service.

```bash
docker-compose -f docker-compose.yml create
```

```bash
docker ps -a
```

```bash
docker cp my.conf <CONTAINER_ID>:/etc/memgraph/my.conf
```

```bash
docker-compose up
```

--------------------------------

### date.format() Usage Example

Source: https://memgraph.com/docs/advanced-algorithms/available-algorithms/date

Example of using the date.format() procedure to get a string representation from a time value.

```cypher
CALL date.format(74976, "h", "%Y/%m/%d %H:%M:%S %Z", "Mexico/BajaNorte")
YIELD formatted RETURN formatted;
```

```text
+-------------------------------+ 
| formatted                     | 
+-------------------------------+ 
| "1978/07/21 17:00:00 PDT"     | 
+-------------------------------+
```

--------------------------------

### Managed Transaction Example

Source: https://memgraph.com/docs/client-libraries/nodejs

An example of a managed transaction using the `session.executeRead()` method to retrieve data.

```javascript
try {
  let session, result
  // Create a session
  session = driver.session()
 
  // The `.executeRead()` method is the entry point into a transaction  
  result = await session.executeRead(async tx => { 
    // Use the method `Transaction.run()` to run queries
    return await tx.run("  
      MATCH (p:Person) WHERE p.name = 'Alice'
      RETURN p.name as name ORDER BY name
      "
    )
  })
  // Process the result records
  for(let record of result.records) {  
    console.log(record.get('name'))
  }
} finally {
  // Remember to close session when done
  session.close()
}
 
```

--------------------------------

### Install Go dependencies

Source: https://memgraph.com/docs/client-libraries/go

Run this command to install dependencies defined in the Go modules.

```bash
go mod tidy
```

--------------------------------

### Id Function Example

Source: https://memgraph.com/docs/data-visualization/graph-style-script/built-in-elements

Example of using the Id function to get the ID of a node or edge and set it as a label.

```gss
label: AsText(Id(node))
```

--------------------------------

### Start Memgraph with snapshot and WAL volumes

Source: https://memgraph.com/docs/database-management/backup-and-restore

Mounts both snapshot and WAL directories to the container at startup.

```bash
docker run -p 7687:7687 -p 7444:7444 -v ~/snapshots:/var/lib/memgraph/snapshots -v ~/wal:/var/lib/memgraph/wal memgraph/memgraph
```

--------------------------------

### Node.js Driver Installation and Usage

Source: https://memgraph.com/docs/getting-started/install-memgraph/memgraph-cloud

Instructions for installing the neo4j-driver in Node.js using npm and a code example to connect and run a query.

```bash
npm install neo4j-driver
```

```javascript
const neo4j = require('neo4j-driver')

const MEMGRAPH_URI = 'bolt+ssc://MEMGRAPH_HOST_ADDRESS:7687';
const MEMGRAPH_USERNAME = 'YOUR_MEMGRAPH_USERNAME';
// Place your Memgraph password that was created during Project creation
const MEMGRAPH_PASSWORD = 'YOUR_MEMGRAPH_PASSWORD';

const helloMemgraph = async (uri, username, password) => {
    const driver = neo4j.driver(uri, neo4j.auth.basic(username, password));

    const session = driver.session();
    const message = 'Hello Memgraph from Node.js!';

    try {
        const result = await session.run(
            `CREATE (n:FirstNode {message: $message}) RETURN n`,
            { message },
        );

        const singleRecord = result.records[0];
        const node = singleRecord.get(0);

        console.log('Created node:', node.properties.message);
    } finally {
        await session.close()
    }

    await driver.close()
};

helloMemgraph(MEMGRAPH_URI, MEMGRAPH_USERNAME, MEMGRAPH_PASSWORD)
    .catch((error) => console.error(error));

```

--------------------------------

### Start the Memgraph Lab Docker container

Source: https://memgraph.com/docs/data-visualization/user-manual/custom-base-path

Command to start Memgraph Lab in a Docker container, exposing port 3000.

```bash
docker run -d -p 3000:3000 --name lab memgraph/lab
```

--------------------------------

### Initialize Application Directory

Source: https://memgraph.com/docs/client-libraries/javascript

Create and navigate to a new directory for the JavaScript application.

```bash
mkdir myApp
cd myApp
```

--------------------------------

### PHP Driver Installation and Usage

Source: https://memgraph.com/docs/getting-started/install-memgraph/memgraph-cloud

Instructions for installing the Memgraph driver in PHP using composer and a code example to connect and run a query.

```bash
composer require stefanak-michal/memgraph-bolt-wrapper
```

```php
<?php
require_once __DIR__ . '/vendor/autoload.php';

// Create a connection class and specify target host and port.
$conn = new \Bolt\connection\StreamSocket('MEMGRAPH_HOST_ADDRESS', '7687');
$conn->setSslContextOptions([
    'peer_name' => 'Memgraph DB',
    'allow_self_signed' => true
]);

// Create a new Bolt instance and provide a connection object.
$bolt = new \Bolt\Bolt($conn);

// Set available Bolt versions for Memgraph.
$bolt->setProtocolVersions(4.1, 4, 3);

// Build and get protocol version instance which creates connection and executes a handshake.
$protocol = $bolt->build();

// Login to database with credentials
$protocol->hello(\Bolt\helpers\Auth::basic('YOUR_MEMGRAPH_USERNAME', 'YOUR_MEMGRAPH_PASSWORD'));

// Pipeline two messages. One to execute query with parameters and second to pull records.
$protocol
    ->run('CREATE (a:Greeting) SET a.message = $message RETURN id(a) AS nodeId, a.message AS message', ['message' => 'Hello, World!'])
    ->pull();

// Server responses are waiting to be fetched through iterator.
$rows = iterator_to_array($protocol->getResponses(), false);

// Get content from requested record.
$row = $rows[1]->getContent();
echo 'Node ' . $row[0] . ' says: ' . $row[1];

```

--------------------------------

### Run the script

Source: https://memgraph.com/docs/client-libraries/nodejs

After running your script with `node example.js` and accessing the root URL `http://localhost:3000` in your web browser, you should receive the output in your terminal similar to this:

```bash
Example app listening at http://localhost:3000
Node 1: Hello, World!
```

--------------------------------

### Start MemGQL container

Source: https://memgraph.com/docs/memgraph-zero/memgql/connect/pinot

Launches the MemGQL service configured to connect to the Pinot broker.

```bash
docker run --rm \
    --name memgql \
    --network memgql-net \
    --stop-timeout 2 \
    -p 7688:7688 \
    --env CONNECTION_TYPE=pinot \
    --env PINOT_URL=http://pinot-broker-dev:8099 \
    --env PINOT_QUERY_OPTIONS=useMultistageEngine=true \
    --env MAPPING_FILE=/data/mapping.json \
    --env BOLT_LISTEN_ADDR=0.0.0.0:7688 \
    -v ./mapping.json:/data/mapping.json \
    memgraph/memgql:latest
```

--------------------------------

### Update Memgraph Lab Docker image and start container

Source: https://memgraph.com/docs/data-visualization/user-manual/custom-base-path

Commands to update the Memgraph Lab Docker image and start a new container.

```bash
docker pull memgraph/lab:latest
docker run -d -p 3000:3000 --name lab memgraph/lab
```

--------------------------------

### Example schema setup for schema.assert()

Source: https://memgraph.com/docs/fundamentals/indexes

Example Cypher statements to create constraints and indexes, which can then be used as input for the `schema.assert()` procedure to demonstrate deleting them.

```cypher
CREATE CONSTRAINT ON (n:Person) ASSERT EXISTS (n.name);
CREATE CONSTRAINT ON (n:Employee) ASSERT n.id IS UNIQUE;
CREATE CONSTRAINT ON (n:Employee) ASSERT n.email IS UNIQUE;
CREATE CONSTRAINT ON (n:Employee) ASSERT n.name, n.surname IS UNIQUE;
CREATE INDEX ON :Student(id);
CREATE INDEX ON :Student;
```

--------------------------------

### Start and Verify Stack

Source: https://memgraph.com/docs/memgraph-zero/memgql/use-cases/public-private

Commands to launch the Docker stack and verify initialization.

```bash
docker compose up -d
```

```bash
docker compose logs memgql-init
# → MemGQL bootstrap complete.
```

--------------------------------

### Connect and Interact with Memgraph in Go

Source: https://memgraph.com/docs/client-libraries/go

Demonstrates how to initialize a driver, verify connectivity, execute Cypher queries for schema and data creation, and retrieve node properties.

```go
package main
 
import (
	"context"
	"fmt"
 
	"github.com/neo4j/neo4j-go-driver/v5/neo4j"
)
 
func main() {
 
	dbUser := ""
	dbPassword := ""
	dbUri := "bolt://localhost:7687" // scheme://host(:port) (default port is 7687)
	driver, err := neo4j.NewDriverWithContext(dbUri, neo4j.BasicAuth(dbUser, dbPassword, ""))
	ctx := context.Background()
	defer driver.Close(ctx)
 
	err = driver.VerifyConnectivity(ctx)
	if err != nil {
		panic(err)
	} else {
		fmt.Println("Viola! Connected to Memgraph!")
	}
 
	//Create indexes on developer and technology nodes
	indexes := []string{
		"CREATE INDEX ON :Developer(id);",
		"CREATE INDEX ON :Technology(id);",
		"CREATE INDEX ON :Developer(name);",
		"CREATE INDEX ON :Technology(name);",
	}
 
	//Create developer nodes
	developer_nodes := []string{
		"CREATE (n:Developer {id: 1, name:'Andy'});",
		"CREATE (n:Developer {id: 2, name:'John'});",
		"CREATE (n:Developer {id: 3, name:'Michael'});",
	}
 
	//Create technology nodes
	technology_nodes := []string{
		"CREATE (n:Technology {id: 1, name:'Memgraph', description: 'Fastest graph DB in the world!', createdAt: Date()})",
		"CREATE (n:Technology {id: 2, name:'Go', description: 'Go programming language ', createdAt: Date()})",
		"CREATE (n:Technology {id: 3, name:'Docker', description: 'Docker containerization engine', createdAt: Date()})",
		"CREATE (n:Technology {id: 4, name:'Kubernetes', description: 'Kubernetes container orchestration engine', createdAt: Date()})",
		"CREATE (n:Technology {id: 5, name:'Python', description: 'Python programming language', createdAt: Date()})",
	}
 
	//Create relationships between developers and technologies
	relationships := []string{
		"MATCH (a:Developer {id: 1}),(b:Technology {id: 1}) CREATE (a)-[r:LOVES]->(b);",
		"MATCH (a:Developer {id: 2}),(b:Technology {id: 3}) CREATE (a)-[r:LOVES]->(b);",
		"MATCH (a:Developer {id: 3}),(b:Technology {id: 1}) CREATE (a)-[r:LOVES]->(b);",
		"MATCH (a:Developer {id: 1}),(b:Technology {id: 5}) CREATE (a)-[r:LOVES]->(b);",
		"MATCH (a:Developer {id: 2}),(b:Technology {id: 2}) CREATE (a)-[r:LOVES]->(b);",
		"MATCH (a:Developer {id: 3}),(b:Technology {id: 4}) CREATE (a)-[r:LOVES]->(b);",
	}
 
	//Create a simple session
	session := driver.NewSession(ctx, neo4j.SessionConfig{DatabaseName: ""})
	defer session.Close(ctx)
 
	// Run index queries via implicit auto-commit transaction
	for _, index := range indexes {
		_, err = session.Run(ctx, index, nil)
		if err != nil {
			panic(err)
		}
	}
	fmt.Println("****** Indexes created *******")
 
	// Run developer node queries
	for _, node := range developer_nodes {
		_, err = neo4j.ExecuteQuery(ctx, driver, node, nil, neo4j.EagerResultTransformer, neo4j.ExecuteQueryWithDatabase(""))
		if err != nil {
			panic(err)
		}
	}
	fmt.Println("****** Developer nodes created *******")
 
	// Run technology node queries
	for _, node := range technology_nodes {
		_, err = neo4j.ExecuteQuery(ctx, driver, node, nil, neo4j.EagerResultTransformer, neo4j.ExecuteQueryWithDatabase(""))
		if err != nil {
			panic(err)
		}
	}
	fmt.Println("****** Technology nodes created *******")
 
	// Run relationship queries
	for _, rel := range relationships {
		_, err = neo4j.ExecuteQuery(ctx, driver, rel, nil, neo4j.EagerResultTransformer, neo4j.ExecuteQueryWithDatabase(""))
		if err != nil {
			panic(err)
		}
	}
	fmt.Println("****** Relationships created *******")
 
	// Read a node
	query := "MATCH (n:Technology{name: 'Memgraph'}) RETURN n;"
	result, err := neo4j.ExecuteQuery(ctx, driver, query, nil, neo4j.EagerResultTransformer, neo4j.ExecuteQueryWithDatabase(""))
	if err != nil {
		panic(err)
	}
 
	
	// Print the node results
	for _, node := range result.Records {
		fmt.Println(node.AsMap()["n"].(neo4j.Node))												// Node type
		fmt.Println(node.AsMap()["n"].(neo4j.Node).GetProperties())								// Node properties
		fmt.Println(node.AsMap()["n"].(neo4j.Node).GetElementId())								// Node internal ID
		fmt.Println(node.AsMap()["n"].(neo4j.Node).Labels)										// Node labels
		fmt.Println(node.AsMap()["n"].(neo4j.Node).Props["id"].(int64))							// Node user defined id property 
		fmt.Println(node.AsMap()["n"].(neo4j.Node).Props["name"].(string))						// Node user defined name property
		fmt.Println(node.AsMap()["n"].(neo4j.Node).Props["description"].(string))				// Node user defined description property
		fmt.Println(node.AsMap()["n"].(neo4j.Node).Props["createdAt"].(neo4j.Date).Time())		// Node user defined createdAt property
 
	}
	fmt.Println("****** End *******")
}
```

--------------------------------

### Database Setup for Degree Centrality Example

Source: https://memgraph.com/docs/advanced-algorithms/available-algorithms/degree_centrality

Cypher queries to create the example graph with nodes and relationships for demonstrating degree centrality calculation.

```cypher
MERGE (a:Node {id: 1}) MERGE (b:Node {id: 0}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 1}) MERGE (b:Node {id: 10}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 2}) MERGE (b:Node {id: 1}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 2}) MERGE (b:Node {id: 10}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 2}) MERGE (b:Node {id: 8}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 3}) MERGE (b:Node {id: 10}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 4}) MERGE (b:Node {id: 2}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 4}) MERGE (b:Node {id: 10}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 5}) MERGE (b:Node {id: 2}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 5}) MERGE (b:Node {id: 10}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 6}) MERGE (b:Node {id: 2}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 7}) MERGE (b:Node {id: 2}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 8}) MERGE (b:Node {id: 2}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 8}) MERGE (b:Node {id: 10}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 9}) MERGE (b:Node {id: 10}) CREATE (a)-[:RELATION]->(b);
MERGE (a:Node {id: 10}) MERGE (b:Node {id: 9}) CREATE (a)-[:RELATION]->(b);
```

--------------------------------

### Start container and attach output

Source: https://memgraph.com/docs/database-management/backup-and-restore

Starts the created container and attaches to the output to monitor logs.

```bash
docker start -a memgraphDB
```

--------------------------------

### Booting MemGQL with a schema file

Source: https://memgraph.com/docs/memgraph-zero/memgql/schema-file

Run the MemGQL Docker container by mounting a local schema file and specifying its path via the --schema flag.

```bash
docker run --rm -p 7688:7688 \
  -e BOLT_LISTEN_ADDR=0.0.0.0:7688 \
  -v "$(pwd)/schema.json:/data/schema.json" \
  memgraph/memgql:latest --schema=/data/schema.json
```

--------------------------------

### Update Memgraph Lab Docker image and start container

Source: https://memgraph.com/docs/memgraph-lab/getting-started/installation-and-deployment

Commands to update the Memgraph Lab Docker image and start a new container.

```bash
docker pull memgraph/lab:latest

Then start the container:

docker run -d -p 3000:3000 --name lab memgraph/lab
```

--------------------------------

### Role Mapping Examples

Source: https://memgraph.com/docs/configuration/auth-module

Examples demonstrating simple and multi-role mapping configurations.

```text
entra.admin:memadmin; entra.user:memuser
```

```text
entra.admin:memadmin; entra.user:memuser, memdev
```

--------------------------------

### Install LightRAG from source

Source: https://memgraph.com/docs/ai-ecosystem/integrations

Required steps to install LightRAG from the repository to enable Memgraph support.

```bash
# Clone the LightRAG repository
git clone https://github.com/HKUDS/LightRAG.git
cd LightRAG
 
# Install from source
pip install -e .
```

--------------------------------

### Setup Graph Data

Source: https://memgraph.com/docs/advanced-algorithms/available-algorithms/refactor

Initial graph structure used for all subsequent refactoring examples.

```Cypher
CREATE (n1:Node {name: "Node 1"})-[:Rel1 {name: "Rel1"}]->(n2:Node {name: "Node 2"})-[:Rel2 {name: "Rel2"}]->(n3:Node {name: "Node 3"})-[:Rel3 {name: "Rel3"}]->(n4:Node {name: "Node 4"})-[:Rel4 {name: "Rel4"}]->(n5:Node {name: "Node 5"});
```

--------------------------------

### Install Cargo for Rust

Source: https://memgraph.com/docs/custom-query-modules/rust/rust-example

Commands to install Cargo (Rust's package manager) and add it to the PATH environment variable within the container.

```bash
curl https://sh.rustup.rs -sSf | sh -s -- -y
export PATH="/root/.cargo/bin:${PATH}"
```

--------------------------------

### Start Neo4j and Memgraph

Source: https://memgraph.com/docs/data-migration/migrate-from-neo4j/using-single-cypher-query

Example command to start Neo4j and Memgraph on different ports, with MAGE pre-installed in the Memgraph Docker image.

```bash
# Start Neo4j (default port 7687)
# Start Memgraph on a different port (7688) with MAGE pre-installed
docker run -it --rm -p 7688:7687 memgraph/memgraph-mage
```

--------------------------------

### Start Iceberg Stack with Docker

Source: https://memgraph.com/docs/memgraph-zero/memgql/connect/iceberg

Sets up a local MinIO instance and an Iceberg REST Catalog using Docker containers.

```bash
docker network create memgql-net
 
# S3-compatible object storage for Iceberg data/metadata files.
docker run -d --rm \
    --name minio-dev \
    --network memgql-net \
    -p 9000:9000 \
    -p 9001:9001 \
    --env MINIO_ROOT_USER=admin \
    --env MINIO_ROOT_PASSWORD=password \
    minio/minio server /data --console-address ":9001"
 
# Create the warehouse bucket.
docker exec minio-dev sh -c \
    "mc alias set local http://localhost:9000 admin password && \
     mc mb --ignore-existing local/warehouse"
 
# Iceberg REST Catalog backed by MinIO.
docker run -d --rm \
    --name iceberg-rest-dev \
    --network memgql-net \
    -p 8181:8181 \
    --env CATALOG_WAREHOUSE=s3://warehouse/ \
    --env CATALOG_IO__IMPL=org.apache.iceberg.aws.s3.S3FileIO \
    --env CATALOG_S3_ENDPOINT=http://minio-dev:9000 \
    --env CATALOG_S3_PATH__STYLE__ACCESS=true \
    --env AWS_ACCESS_KEY_ID=admin \
    --env AWS_SECRET_ACCESS_KEY=password \
    --env AWS_REGION=us-east-1 \
    tabulario/iceberg-rest
```

--------------------------------

### Implement LightRAG with Memgraph

Source: https://memgraph.com/docs/ai-ecosystem/integrations

Basic usage example showing how to initialize LightRAG with MemgraphStorage and perform a hybrid query.

```python
import os
import asyncio
from lightrag import LightRAG, QueryParam
from lightrag.llm.openai import gpt_4o_mini_complete, gpt_4o_complete, openai_embed
from lightrag.kg.shared_storage import initialize_pipeline_status
from lightrag.utils import setup_logger
 
setup_logger("lightrag", level="INFO")
 
WORKING_DIR = "./rag_storage"
if not os.path.exists(WORKING_DIR):
    os.mkdir(WORKING_DIR)
 
async def initialize_rag():
    rag = LightRAG(
        working_dir=WORKING_DIR,
        embedding_func=openai_embed,
        llm_model_func=gpt_4o_mini_complete,
        graph_storage="MemgraphStorage", #<-----------override KG default
    )
    # IMPORTANT: Both initialization calls are required!
    await rag.initialize_storages()  # Initialize storage backends
    await initialize_pipeline_status()  # Initialize processing pipeline
    return rag
 
async def main():
    try:
        # Initialize RAG instance
        rag = await initialize_rag()
        rag.insert("Your text")
 
        # Perform hybrid search
        mode = "hybrid"
        print(
          await rag.query(
              "What are the top themes in this story?",
              param=QueryParam(mode=mode)
          )
        )
 
    except Exception as e:
        print(f"An error occurred: {e}")
    finally:
        if rag:
            await rag.finalize_storages()
 
if __name__ == "__main__":
    asyncio.run(main())
```

--------------------------------

### Example command for copying mgp.py

Source: https://memgraph.com/docs/custom-query-modules/python/implement-custom-query-module-in-python

An example of the docker cp command with a specific container ID and local path.

```bash
C:\Users\Vlasta\Desktop>docker cp 63e35:/usr/lib/memgraph/python_support/mgp.py mgp.py
```

--------------------------------

### Start Memgraph Platform on Windows

Source: https://memgraph.com/docs/client-libraries/go

Execute this command in PowerShell to download and start the Memgraph Platform.

```powershell
iwr https://windows.memgraph.com | iex
```

--------------------------------

### Initialize graph data

Source: https://memgraph.com/docs/fundamentals/data-types

Setup script to create nodes and relationships for map projection examples.

```cypher
MATCH (n) DETACH DELETE n;
CREATE
(bradley:Person {name: 'Bradley Cooper', oscars: 0}),
(jennifer:Person {name: 'Jennifer Lawrence', oscars: 1}),
(slp:Movie {title: 'Silver Linings Playbook', released: 2012}),
(amhu:Movie {title: 'American Hustle', released: 2013}),
(joy:Movie {title: 'Joy', released: 2015}),
(asib:Movie {title: 'A Star Is Born', released: 2018}),
(dlu:Movie {title: 'Don’t Look Up', released: 2021}),
(bradley)-[:ACTED_IN]->(slp),
(bradley)-[:ACTED_IN]->(amhu),
(bradley)-[:ACTED_IN]->(joy),
(bradley)-[:ACTED_IN]->(asib),
(jennifer)-[:ACTED_IN]->(slp),
(jennifer)-[:ACTED_IN]->(amhu),
(jennifer)-[:ACTED_IN]->(joy),
(jennifer)-[:ACTED_IN]->(dlu);
```

--------------------------------

### Start Memgraph Services

Source: https://memgraph.com/docs/memgraph-zero/memgql/complete

Commands to initialize the Docker environment and verify container health.

```bash
docker compose up -d
```

```bash
docker compose ps
```

--------------------------------

### Install Required Dependencies

Source: https://memgraph.com/docs/custom-query-modules/cpp/cpp-example

Commands to update package lists and install necessary dependencies (git, cmake, clang, vim) within the container.

```bash
 apt update -y
 apt install -y git cmake clang clangd vim
```

--------------------------------

### node_boundary Usage

Source: https://memgraph.com/docs/advanced-algorithms/available-algorithms/nxalg

Example query to get the node boundary using node_boundary.

```cypher
MATCH (n:Label)
COLLECT (n) AS sources1
CALL nxalg.node_boundary(sources1) 
YIELD boundary
RETURN boundary;
```

--------------------------------

### Install perf tools

Source: https://memgraph.com/docs/database-management/debugging

Access the debug pod and install the necessary Linux profiling tools.

```bash
kubectl exec -it debug -- bash
```

```bash
apt-get update && apt-get install -y linux-tools-common linux-tools-generic
```

```bash
/usr/lib/linux-tools/*/perf record ...
```

--------------------------------

### Example of creating indexes and relationships

Source: https://memgraph.com/docs/data-migration/best-practices

Demonstrates creating nodes with properties and then establishing a relationship between them, illustrating the need for indexes.

```cypher
CREATE (:Person {id: 1});
CREATE (:Person {id: 2});
 
MATCH (p1:Person {id: 1}), (p2:Person {id:2})
CREATE (p1)-[:IS_FRIENDS_WITH]->(p2);
```

--------------------------------

### global_efficiency() Usage

Source: https://memgraph.com/docs/advanced-algorithms/available-algorithms/nxalg

Example query to get the average global efficiency of the graph.

```cypher
CALL nxalg.global_efficiency() 
YIELD global_efficiency
RETURN global_efficiency;
```

--------------------------------

### flow_hierarchy() Usage

Source: https://memgraph.com/docs/advanced-algorithms/available-algorithms/nxalg

Example query to get the flow hierarchy of a directed network.

```cypher
CALL nxalg.flow_hierarchy() 
YIELD 
RETURN flow_hierarchy;
```

--------------------------------

### Start Memgraph via Docker

Source: https://memgraph.com/docs/ai-ecosystem/integrations

Quickly initialize a Memgraph instance using Docker for local development.

```bash
docker run -p 7687:7687 memgraph/memgraph:latest
```

--------------------------------

### Start Memgraph with schema tracking

Source: https://memgraph.com/docs/ai-ecosystem/agents/sql2graph-agent

Launch a Memgraph instance with the required schema information enabled for migration functionality.

```bash
docker run -p 7687:7687 memgraph/memgraph --schema-info-enabled
```

--------------------------------

### Get Examples

Source: https://memgraph.com/docs/data-visualization/graph-style-script/built-in-elements

Illustrates retrieving elements from lists, maps, strings, nodes, and relationships.

```gss
Get(AsArray(3,6,7,3), 2)
```

```gss
Get(Property(node, "map"), "year")
```

--------------------------------

### Install Cognee Dependencies

Source: https://memgraph.com/docs/ai-ecosystem/integrations

Commands to initialize a project and install necessary Python packages.

```bash
poetry init
poetry add cognee
pip install neo4j
```

--------------------------------

### Type Function Example

Source: https://memgraph.com/docs/data-visualization/graph-style-script/built-in-elements

Demonstrates using the Type function to get the type of a relationship.

```gss
label: Type(edge)
```
Tokens:
Raw