### Run Linkurious Ogma Example Application

Source: https://doc.linkurious.com/ogma/latest/examples/geo-marker-cluster

Instructions to install dependencies and start the local development server for the Linkurious Ogma example. Before running, ensure to replace the `YOUR_ACCESS_KEY` placeholder in `package.json` with a valid API key.

```sh
npm install
npm start
```

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

### Setup Ogma React JavaScript Project with Create React App

Source: https://doc.linkurious.com/ogma/latest/tutorials/react-cra/index

Commands to initialize a new React application using `create-react-app` with the Ogma JavaScript template. This snippet includes steps for both npm and yarn package managers to create the project and install the Ogma library, ensuring a quick start for development.

```sh
npx create-react-app my-app --template "@linkurious/ogma" --use-npm
cd my-app
npm install --save https://get.linkurio.us/api/get/npm/ogma/<VERSION>/?secret=<YOUR_API_KEY>
```

```sh
yarn create react-app my-app --template "@linkurious/ogma"
cd my-app
yarn add https://get.linkurio.us/api/get/npm/ogma/<VERSION>.tgz?secret=<YOUR_API_KEY>
```

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

### Manual Plugin Installation Steps for Linkurious Enterprise

Source: https://doc.linkurious.com/admin-manual/latest/page

A step-by-step guide for manually installing Linkurious Enterprise plugins, requiring write access to the installation folder and an application admin account.

```APIDOC
1. Obtain the .lke file of the plugin you need to install, for official plugins you can download it from the Releases section of the plugin page
2. Copy the .lke file to the following path <linkurious>/data/plugins
3. From the Linkurious Enterprise dashboard, go to Admin -> Global configuration
4. Scroll to the Plugins settings field
5. Add a space at the end of the Plugins settings section
6. Click "Save". This will restart all the plugins to apply the new configurations.
```

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

### Install Ogma from a downloaded tar.gz file

Source: https://doc.linkurious.com/ogma/latest/tutorials/getting-started/install

How to install Ogma using npm from a locally downloaded .tar.gz archive, useful when direct external npm access is restricted.

```sh
npm install --save path/to/ogma-v.X.X.X.tar.gz
```

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

### Amazon Neptune to OpenSearch Full-Text Search Integration Quick Start

Source: https://doc.linkurious.com/admin-manual/latest/page

Outlines a simplified quick-start guide for integrating Amazon Neptune with Amazon OpenSearch for full-text search, covering essential AWS setup steps such as IAM role configuration, Neptune streams enablement, OpenSearch instance creation, and synchronization job setup.

```APIDOC
1. Make sure the [IAM role](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) running Neptune can also run queries in OpenSearch
2. Enable Neptune streams
   * Open the ["parameter groups" section in your Neptune console](https://console.aws.amazon.com/neptune/home#parameter-groups))
   * Click the "create new parameter group" button
   * Set the "type" to "DB cluster parameter group"
   * Click the "edit parameter" button
   * Set `neptune_streams` to `1`
   * Save this new parameter group
   * Edit your Neptune instance to use the parameter group you just created
3. Create an OpenSearch instance
   * Open your [OpenSearch console](https://console.aws.amazon.com/aos/home)
   * Create a new OpenSearch instance (choose either Elasticsearch 7.10 or OpenSearch 1.3)
   * Choose network settings that allow Neptune and OpenSearch to communicate (i.e. same VPC, same subnet)
4. Set up the Neptune-to-OpenSearch synchronization
   * [Choose the region in which to deploy the synchronization job](https://docs.aws.amazon.com/neptune/latest/userguide/full-text-search-cfn-create.html#full-text-search-cfn-by-region)
   * [Fill in details, as recommended](https://docs.aws.amazon.com/neptune/latest/userguide/full-text-search-cfn-create.html#full-text-search-cfn-stack-details)
   * Select VPC & subnets so that it can communicate with your Neptune & OpenSearch instances
```

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

### Setup Ogma React TypeScript Project with Create React App

Source: https://doc.linkurious.com/ogma/latest/tutorials/react-cra/index

Commands to initialize a new React application using `create-react-app` with the Ogma TypeScript template. This snippet provides steps for both npm and yarn package managers to create the project and install the Ogma library, facilitating a rapid setup for TypeScript-based development.

```sh
npx create-react-app my-app --template "@linkurious/ogma-ts" --use-npm
cd my-app
npm install --save https://get.linkurio.us/api/get/npm/ogma/<VERSION>/?secret=<YOUR_API_KEY>
```

```sh
yarn create react-app my-app --template "@linkurious/ogma-ts"
cd my-app
yarn add https://get.linkurio.us/api/get/npm/ogma/<VERSION>.tgz?secret=<YOUR_API_KEY>
```

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

### Install Ogma via npm, yarn, or pnpm

Source: https://doc.linkurious.com/ogma/latest/tutorials/getting-started/install

Instructions for installing the Ogma library as a project dependency using popular JavaScript package managers. An API key is required for direct installation from Linkurious's private registry.

```sh
# NPM
npm install --save https://get.linkurio.us/api/get/npm/ogma/<VERSION>/?secret=<YOUR_API_KEY>
```

```sh
# note the quotes around the URL, they are required for yarn to parse it correctly
yarn add "https://get.linkurio.us/api/get/npm/ogma/<VERSION>/?secret=<YOUR_API_KEY>"
```

```sh
# same as npm)
pnpm install --save https://get.linkurio.us/api/get/npm/ogma/<VERSION>/?secret=<YOUR_API_KEY>
```

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

### Example Linkurious Enterprise Elasticsearch Data Source Configuration

Source: https://doc.linkurious.com/admin-manual/4.2/page

Provides a JSON example demonstrating how to configure an Elasticsearch data source within Linkurious Enterprise, showing typical settings for host, port, and edge indexing.

```json
{
  "dataSources": [
    {
      "graph": {
        "vendor": "neo4j",
        "url": "http://127.0.0.1:7474"
      },
      "index": {
        "vendor": "elasticSearch",
        "host": "192.168.1.122",
        "port": 9200,
        "skipEdgeIndexing": true
      }
    }
  ]
}
```

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

### Amazon Neptune to OpenSearch Full-Text Search Integration Guide

Source: https://doc.linkurious.com/admin-manual/4.2/page

Outlines the step-by-step process for setting up full-text search synchronization between Amazon Neptune and Amazon OpenSearch, covering IAM roles, Neptune streams, OpenSearch instance creation, and synchronization job setup.

```APIDOC
Amazon Neptune to OpenSearch Integration Steps:
1. Make sure the IAM role running Neptune can also run queries in OpenSearch
2. Enable Neptune streams:
   - Open the "parameter groups" section in your Neptune console
   - Click the "create new parameter group" button
   - Set the "type" to "DB cluster parameter group"
   - Click the "edit parameter" button
   - Set neptune_streams to 1
   - Save this new parameter group
   - Edit your Neptune instance to use the parameter group you just created
3. Create an OpenSearch instance:
   - Open your OpenSearch console
   - Create a new OpenSearch instance (choose either Elasticsearch 7.10 or OpenSearch 1.3)
   - Choose network settings that allow Neptune and OpenSearch to communicate (i.e. same VPC, same subnet)
4. Set up the Neptune-to-OpenSearch synchronization:
   - Choose the region in which to deploy the synchronization job
   - Fill in details, as recommended
   - Select VPC & subnets so that it can communicate with your Neptune & OpenSearch instances
```

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

### Example JSON Configuration for Elasticsearch Search Connector

Source: https://doc.linkurious.com/admin-manual/latest/page

Provides a practical JSON example demonstrating how to configure the Elasticsearch search connector within a Linkurious Enterprise data source, specifying host, port, and indexing preferences.

```JSON
{
  "dataSources": [
    {
      "graph": {
        "vendor": "neo4j",
        "url": "http://127.0.0.1:7474"
      },
      "index": {
        "vendor": "elasticSearch",
        "host": "192.168.1.122",
        "port": 9200,
        "skipEdgeIndexing": true
      }
    }
  ]
}
```

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

### Navigate to Linkurious Enterprise Directory on macOS

Source: https://doc.linkurious.com/admin-manual/4.2/install

Changes the current working directory to the Linkurious Enterprise installation folder on macOS, preparing for subsequent setup steps.

```bash
cd linkurious-osx
```

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

### Import Ogma as an ES module

Source: https://doc.linkurious.com/ogma/latest/tutorials/getting-started/install

Shows how to import Ogma using the ECMAScript module syntax, compatible with modern JavaScript environments and bundlers.

```js
import Ogma from '@linkurious/ogma';
```

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

### Import Ogma in a single HTML page

Source: https://doc.linkurious.com/ogma/latest/tutorials/getting-started/install

Demonstrates how to include the Ogma library directly in an HTML file using a script tag, suitable for single-page applications or simple web projects.

```html
<!-- Import Ogma -->
<script src="path/to/ogma.js"></script>
```

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

### Setup HTML Container for Ogma Graph

Source: https://doc.linkurious.com/ogma/latest/examples/manual-resizing

This HTML snippet provides the basic page structure required to display the Ogma graph. It defines a full-page container div for the graph and includes a script tag to load the main TypeScript module, which contains the graph initialization and interaction logic.

```html
<body>
  <head></head>
  <title>Manual resizing</title>

  <div
    id="graph-container"
    style="top: 0; bottom: 0; left: 0; right: 0; position: absolute; margin: 0"
  ></div>
  <script type="module" src="index.ts"></script>
</body>
```

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

### Basic HTML Structure for Ogma.js Neo4j Example

Source: https://doc.linkurious.com/ogma/latest/examples/connector-neo4j

This HTML snippet provides the foundational page structure for the Neo4j and Ogma.js integration example. It sets up the document, includes necessary meta tags, links to external CSS for styling (Lucide font icons), and imports the `neo4j-driver` JavaScript library from a CDN, preparing the environment for the graph visualization.

```html
<!doctype html>
<html>
  <head>
    <meta charset="utf-8" />

    <script src="https://cdn.jsdelivr.net/npm/neo4j-driver@4.0.1/lib/browser/neo4j-web.min.js"></script>
    <link
      href="https://cdn.jsdelivr.net/npm/lucide-static@0.483.0/font/lucide.css"
      rel="stylesheet"
    />
    <link

```

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

### Linkurious Enterprise Command-Line Administration Utilities

Source: https://doc.linkurious.com/admin-manual/latest/page

A collection of shell scripts for managing the Linkurious Enterprise server. These commands allow users to start, stop, check the status, and manage the installation of Linkurious Enterprise as a system-wide service.

```bash
./linkurious/start.sh
```

```bash
./linkurious/stop.sh
```

```bash
./linkurious/menu.sh
```

```bash
./linkurious/menu.sh status
```

```bash
./linkurious/menu.sh install
```

```bash
./linkurious/menu.sh uninstall
```

```bash
./linkurious/menu.sh help
```

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

### Configure Linkurious Enterprise with MySQL

Source: https://doc.linkurious.com/admin-manual/4.2/page

An example JSON configuration snippet for connecting Linkurious Enterprise to a MySQL database. This setup includes specifying the database name, username, password, host, and port for the MySQL server.

```JSON
"db": {
    "name": "linkurious",
    "username": "MYSQL_USER_NAME",
    "password": "MYSQL_PASSWORD",
    "options": {
      "dialect": "mysql",
      "host": "MYSQL_HOST",
      "port": 3306
    }
}
```

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

### Configure Linkurious Enterprise with MariaDB

Source: https://doc.linkurious.com/admin-manual/4.2/page

An example JSON configuration snippet for connecting Linkurious Enterprise to a MariaDB database. This setup includes the database name, username, password, host, and the standard port (3306) for MariaDB connections.

```JSON
"db": {
    "name": "linkurious",
    "username": "MARIADB_USER_NAME",
    "password": "MARIADB_PASSWORD",
    "options": {
      "dialect": "mariadb",
      "host": "MARIADB_HOST",
      "port": 3306
    }
}
```

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

### Set up and run Mocha tests for Ogma applications

Source: https://doc.linkurious.com/ogma/latest/tutorials/testing

Instructions for installing Mocha, Chai, and Canvas as development dependencies, followed by an example JavaScript test suite demonstrating how to initialize Ogma, set a graph, and assert node count using Chai.

```sh
npm install --save-dev mocha chai canvas
mocha tests/**/*.test.js
```

```js
import Ogma = from '@linkurious/ogma';
import { assert } from 'chai';

describe('dummy suite', () => {
  it('dummy test', () => {
    const ogma = new Ogma();
    return ogma
      .setGraph({
        nodes: [{ id: 0 }, { id: 1 }],
        edges: [{ source: 0, target: 1 }]
      })
      .then(() => {
        assert.equal(ogma.getNodes().size, 2);
      });
  });
});
```

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

### Linkurious Enterprise Administration Command-Line Utilities

Source: https://doc.linkurious.com/admin-manual/4.2/page

A comprehensive list of shell scripts and commands used for managing the Linkurious Enterprise server. These utilities allow users to start, stop, check the status, and manage the installation or uninstallation as a system-wide service.

```bash
./linkurious/start.sh
./linkurious/stop.sh
./linkurious/menu.sh
./linkurious/menu.sh status
./linkurious/menu.sh install
./linkurious/menu.sh uninstall
./linkurious/menu.sh help
```

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

### Display a Basic Graph with Ogma.js in HTML

Source: https://doc.linkurious.com/ogma/latest/tutorials/getting-started/hello_world

This HTML snippet demonstrates how to create a simple 'Hello World' graph using the Ogma.js library. It initializes an Ogma instance, binds it to a DOM container, then adds two nodes ('n0' and 'n1') with specified positions, and connects them with an arrow-shaped edge. The example requires the Ogma.js library to be included via a script tag.

```html
<html>
  <head>
    <!-- Include the library -->
    <script src="../build/ogma.js"></script>
    <style type="css">
      #graph-container {
        width: 500px;
        height: 500px;
      }
    </style>
  </head>
  <body>
    <!-- DOM element containing the graph -->
    <div id="graph-container"></div>

    <script>
      // Create an instance of Ogma and bind it to the graph-container.
      const ogma = new Ogma({
        container: 'graph-container'
      });

      // Create a node with id 'n0'.
      const n0 = { id: 'n0', attributes: { x: 0, y: 0 } };
      // Add the node to ogma.
      ogma.addNode(n0);

      // Create a node with id 'n1'.
      const n1 = { id: 'n1', attributes: { x: 50, y: 0 } };
      // Add the node to ogma.
      ogma.addNode(n1);

      // Create an edge from 'n0' to 'n1'
      const e = {
        id: 'e0',
        source: 'n0',
        target: 'n1',
        attributes: {
          shape: 'arrow'
        }
      };
      // Add the edge to ogma.
      ogma.addEdge(e);
    </script>
  </body>
</html>
```

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

### Apply Svelte `use:action` Directive to Ogma Container

Source: https://doc.linkurious.com/ogma/latest/tutorials/svelte

This HTML snippet demonstrates how to integrate the previously defined `setup` Svelte action with the Ogma container `div` element. By using the `use:setup` directive, the `setup` function is automatically invoked when the `div` is mounted to the DOM, facilitating the lazy and controlled initialization of the Ogma instance.

```html
<div id="container" use:setup></div>
```

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

### Example: Start Entity Resolution Ingestion Task Success Response

Source: https://doc.linkurious.com/server-sdk/latest/apidoc

An example of a successful HTTP 204 No Content response after starting an entity resolution ingestion task, indicating the task has been initiated.

```JSON
HTTP/1.1 204 No Content
```

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

### Initial GUI Setup and Style Application (JavaScript)

Source: https://doc.linkurious.com/ogma/latest/examples/all-attributes

This code block initializes the Tweakpane GUI with the application's current custom styles. It sets up the GUI for 'all' elements and then applies specific styles for 'selected' and 'hovered' states, ensuring the visual representation matches the configured styles upon application load and user interaction.

```javascript
gui = init(
  'all',
  customStyle.nodes.all,
  customStyle.edges.all,
  typeChange,
  updateNodeAttributes,
  updateEdgeAttributes,
  () => fileInput.click(),
  export_,
  reset
);
// Update the other types (selected + hovered)
updateNodeAttributes('selected', customStyle.nodes.selected);
updateEdgeAttributes('selected', customStyle.edges.selected);
updateNodeAttributes('hovered', customStyle.nodes.hovered);
updateEdgeAttributes('hovered', customStyle.edges.hovered);
```

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

### Auth - Get Current User Error 401 Example

Source: https://doc.linkurious.com/server-sdk/latest/apidoc

An example of the JSON response body for a 401 Unauthorized error, indicating that the request to get the current user's profile failed due to insufficient authentication or an invalid session.

```JSON
{
  "key": "unauthorized",
  "message": "Unauthorized."
}
```

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

### Retrieve Linkurious Enterprise API Version and Status

Source: https://doc.linkurious.com/admin-manual/latest/page

Details the process of querying the Linkurious Enterprise API for its version information. It includes the HTTP GET request endpoint and an example JSON response structure, showing fields like tag name, release name, and enterprise status.

```APIDOC
Endpoint: GET /api/version
Host: 127.0.0.1:3000 (replace with actual host and port)
Description: Retrieves the current API version and status of Linkurious Enterprise.
```

```JSON
{
  "tag_name": "4.2.1",
  "name": "Brilliant Burrito",
  "prerelease": false,
  "enterprise": true
}
```

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

### Setup HTML Structure for Ogma.js Graph and Tooltips

Source: https://doc.linkurious.com/ogma/latest/examples/tooltips-mustache

This HTML file defines the basic page structure, links necessary CSS and font resources (Lucide and IBM Plex Sans), and includes a container for the Ogma graph. It also imports the main TypeScript module as a type='module' script.

```html
<!doctype html>
<html>
  <head>
    <meta charset="utf-8" />
    <link
      href="https://cdn.jsdelivr.net/npm/lucide-static@0.483.0/font/lucide.css"
      rel="stylesheet"
    />
    <link
      href="https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:ital,wght@0,100;0,200;0,300;0,400;0,500;0,600;0,700;1,100;1,200;1,300;1,400;1,500;1,600;1,700&display=swap"
      rel="stylesheet"
    />
    <link type="text/css" rel="stylesheet" href="styles.css" />
  </head>

  <body>
    <div id="graph-container"></div>
    <!-- force icon font loading -->
    <i class="icon-camera" style="color: rgba(0, 0, 0, 0)"></i>
    <script type="module" src="index.ts"></script>
  </body>
</html>
```

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

### Set up and run Jasmine tests for Ogma applications

Source: https://doc.linkurious.com/ogma/latest/tutorials/testing

Instructions for installing Jasmine as a development dependency, followed by an example JavaScript test suite demonstrating how to initialize Ogma, set a graph, and assert node count using Jasmine's `expect` syntax.

```sh
npm i --save-dev jasmine
jasmine
```

```js
const Ogma = require('@linkurious/ogma');

describe('dummy suite', () => {
  it('dummy test', () => {
    const ogma = new Ogma();
    return ogma
      .setGraph({
        nodes: [{ id: 0 }, { id: 1 }],
        edges: [{ source: 0, target: 1 }]
      })
      .then(() => {
        expect(ogma.getNodes().size).toBe(2);
      });
  });
});
```

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

### Upload Linkurious Enterprise to Custom Docker Registry

Source: https://doc.linkurious.com/admin-manual/4.2/install

Example commands to transfer the Linkurious Enterprise Docker image from the Linkurious private registry to an organization's own private registry. This process involves logging into the custom registry, tagging the image, and pushing it, ensuring better availability and control.

```Shell
docker login MY_PRIVATE_REGISTRY
docker tag LINKURIOUS_PRIVATE_REGISTRY/linkurious/linkurious-enterprise:4.2.1 MY_PRIVATE_REGISTRY/linkurious-enterprise
docker push MY_PRIVATE_REGISTRY/linkurious-enterprise:4.2.1
```

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

### Install Ogma React Wrapper via npm

Source: https://doc.linkurious.com/ogma/latest/tutorials/react-wrapper

Instructions for installing the @linkurious/ogma-react library using npm. This includes a placeholder for a private npm link (if applicable) and the standard public package installation command.

```bash
$ npm install -S <YOUR_NPM_LINK_FROM_GET.LINKURIO.US>
$ npm install -S @linkurious/ogma-react
```

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

### Start Linkurious Enterprise Docker with Memory Limits

Source: https://doc.linkurious.com/admin-manual/latest/page

This example shows how to run the Linkurious Enterprise Docker container with a specified memory limit using `--memory`. It also sets the Node.js `--max-old-space-size` environment variable, which is crucial for optimizing memory usage within the container, especially when not using the embedded Elasticsearch instance.

```Docker
docker run -d --rm \
    -p 3000:3000 \
    --mount type=bind,src=/path/to/my/data/folder,dst=/data \
    --memory 1024m \
    -e NODE_OPTIONS='--max-old-space-size=984' \
    linkurious:4.2.1
```

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

### Setup Ogma Graph Container (HTML)

Source: https://doc.linkurious.com/ogma/latest/examples/shortest-path

This HTML code provides the basic structure for the web page. It includes a `div` element with the ID `graph-container`, which serves as the target for the Ogma graph visualization. It also links to the external stylesheet and imports the main TypeScript module as a type='module' script.

```html
<!doctype html>
<html>
  <head>
    <meta charset="utf-8" />

    <link type="text/css" rel="stylesheet" href="styles.css" />
  </head>

  <body>
    <div id="graph-container"></div>
    <script type="module" src="index.ts"></script>
  </body>
</html>
```

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

### Unzip Linkurious Enterprise Archive on Linux

Source: https://doc.linkurious.com/admin-manual/4.2/install

Unzips the Linkurious Enterprise distribution archive for Linux systems, preparing the application files for installation.

```bash
unzip linkurious-linux-v4.2.1.zip
```

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

### Import Ogma in Node.js (Server-side)

Source: https://doc.linkurious.com/ogma/latest/tutorials/getting-started/install

Illustrates how to import the Ogma library for server-side usage in a Node.js environment, supporting both npm-installed and manually downloaded versions.

```ts
// if you installed Ogma via npm CLI
import Ogma from '@linkurious/ogma';

// of if you downloaded the js file manually
import Ogma from 'path/to/ogma.js';
```

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

### Linux Installation Commands for Linkurious Enterprise

Source: https://doc.linkurious.com/admin-manual/latest/page

A sequence of shell commands to install Linkurious Enterprise on a Linux system, including unzipping the archive, creating a dedicated service account, adjusting file ownership, and navigating to the installation directory.

```shell
unzip linkurious-linux-v4.2.1.zip
```

```shell
useradd -r linkurious
```

```shell
chown -R linkurious:linkurious /linkurious-linux
```

```shell
cd linkurious-linux
```

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

### Initialize Node.js Project and Install Spanner/Web Dependencies

Source: https://doc.linkurious.com/ogma/latest/tutorials/spanner

This `npm` command initializes a new Node.js project and installs all necessary development dependencies. It includes `typescript`, `ts-node` for TypeScript execution, `express` and `vite` for the web server, `@google-cloud/spanner` for database interaction, `dotenv` for environment variables, `uuid` for ID generation, and `csv-parser` for data parsing.

```bash
npm init -y
npm install typescript ts-node @types/node express tsx vite @google-cloud/spanner dotenv uuid csv-parser --save-dev
```

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

### Unzip Linkurious Enterprise Archive on macOS

Source: https://doc.linkurious.com/admin-manual/4.2/install

Unzips the Linkurious Enterprise distribution archive for macOS systems, making the application files accessible for installation.

```bash
unzip linkurious-osx-v4.2.1.zip
```

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

### Create New Vue Project with Vue CLI

Source: https://doc.linkurious.com/ogma/latest/tutorials/vue

Uses the `vue-cli` package via `npx` to create a new Vue application directory, serving as the starting point for the Ogma integration.

```sh
npx @vue/cli create vue-ogma-project
```

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

### Navigate to Linkurious Enterprise Directory on Linux

Source: https://doc.linkurious.com/admin-manual/4.2/install

Changes the current working directory to the Linkurious Enterprise installation folder on Linux, a prerequisite for further configuration or execution.

```bash
cd linkurious-linux
```

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

### Example Plugin Configuration JSON

Source: https://doc.linkurious.com/admin-manual/latest/page

This JSON object illustrates how to configure multiple instances of different plugins within Linkurious Enterprise's plugin settings. It demonstrates deploying a plugin with its default path and multiple instances of another plugin with custom base paths.

```JSON
{
  "my-plugin": [
  ],
  "my-second-plugin": [
    {
      "basePath": "my-path"
    },
    {
      "basePath": "my-other-path"
    }
  ]
}
```

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

### Configure Linkurious SAML2 Access with JSON

Source: https://doc.linkurious.com/admin-manual/4.2/page

This JSON snippet provides a concrete example of how to configure SAML2 authentication within the Linkurious Enterprise 'access' block. It demonstrates enabling SAML2, specifying the identity provider's URL, setting the path to the identity provider's certificate, and defining the attribute for user groups, illustrating a typical setup.

```json
"access": {
  // [...]
  "saml2": {
    "enabled": true,
    "url": "https://example.com/adfs/ls",
    "identityProviderCertificate": "/Users/example/linkurious/saml.pem",
    "groupAttribute": "Groups"
  }
}
```

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

### Example: Get Entity Resolution Mappings Success Response

Source: https://doc.linkurious.com/server-sdk/latest/apidoc

An example of a successful HTTP 200 OK response when retrieving entity resolution mappings, showing a list of mapping objects.

```JSON
HTTP/1.1 200 OK
{
  "items": [
    {
      "id": 17,
      "sourceNodeCategory": "account",
      "targetRecordType": "person",
      "properties": [
        {
          "sourcePropertyKey": "ssn",
          "targetAttribute": "ssnNumber"
        },
        {
          "sourcePropertyKey": "name",
          "targetAttribute": ["names", "primary", "full"]
        }
      ]
    }
  ]
}
```

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

### Set up and run Jest tests for Ogma applications

Source: https://doc.linkurious.com/ogma/latest/tutorials/testing

Instructions for installing Jest and Canvas as development dependencies, followed by an example JavaScript test suite demonstrating how to initialize Ogma, set a graph, and assert node count using Jest's `expect` syntax.

```sh
npm i --save-dev jest canvas
jest
```

```js
const Ogma = require('@linkurious/ogma');

describe('dummy suite', () => {
  test('dummy test', () => {
    const ogma = new Ogma();
    return ogma
      .setGraph({
        nodes: [{ id: 0 }, { id: 1 }],
        edges: [{ source: 0, target: 1 }]
      })
      .then(() => {
        expect(ogma.getNodes().size).toBe(2);
      });
  });
});
```

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

### process_start_time_seconds

Source: https://doc.linkurious.com/admin-manual/4.2/page

Start time of the process since unix epoch in seconds.

```Prometheus Exposition Format
# HELP process_start_time_seconds Start time of the process since unix epoch in seconds.
# TYPE process_start_time_seconds gauge
process_start_time_seconds 1693901797
```

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

### Setup HTML Page for Ogma Graph Container

Source: https://doc.linkurious.com/ogma/latest/examples/layout-grid

This HTML snippet defines the basic structure for a web page that hosts an Ogma graph. It includes a `div` element as the graph container, links to a stylesheet for styling, and imports the `dat.gui` library for interactive controls, along with the main TypeScript application file as a module.

```html
<!doctype html>
<html>
  <head>
    <meta charset="utf-8" />
    <link type="text/css" rel="stylesheet" href="styles.css" />
    <script src="https://cdn.jsdelivr.net/npm/dat.gui@0.7.9/build/dat.gui.min.js"></script>
  </head>
  <body>
    <div id="graph-container"></div>
    <script type="module" src="index.ts"></script>
  </body>
</html>
```

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

### Node API: Get Adjacent Nodes HTTP 200 OK Example

Source: https://doc.linkurious.com/server-sdk/latest/apidoc

An example of a successful HTTP 200 OK response for the adjacent nodes API, showing the structure of returned nodes and edges.

```HTTP
HTTP/1.1 200 OK
{
  "nodes": [
    {
      "id": "1",
      "data": {
        "categories": ["Person"],
        "properties": {
          "name": "David"
        },
        "geo": {},
        "isVirtual": false,
        "statistics": {
          "supernode": false,
          "digest": [
            {
              "nodeCategories": [
                "Company"
              ],
              "edgeType": "works_for",
              "nodes": 1,
              "edges": 1
            }
          ]
        },
        "readAt": 692362800000
      }
    }
  ],
  "edges": [
    {
      "id": "1",
      "source": "1",
      "target": "2",
      "data": {
        "type": "works_for",
        "properties": {
          "since": "2016-05-09"
        },
        "readAt": 692362800000,
        "isVirtual": false
      }
    }
  ]
}
```

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

### Basic HTML Structure for Ogma Graph and Tweakpane UI

Source: https://doc.linkurious.com/ogma/latest/examples/settings

This HTML file sets up the basic page structure, including linking external CSS (styles.css), importing necessary JavaScript libraries (Tweakpane, Lucide icons, IBM Plex Sans font, Lodash), and defining two main `div` containers: one for the Ogma graph visualization (`graph-container`) and another for the Tweakpane UI (`gui-container`). It also links the main JavaScript logic file (index.js).

```html
<!doctype html>
<html>
  <head>
    <meta charset="utf-8" />

    <link type="text/css" rel="stylesheet" href="styles.css" />
    <script src="https://cdn.jsdelivr.net/npm/tweakpane@1.5.7/dist/tweakpane.min.js"></script>
    <link
      href="https://cdn.jsdelivr.net/npm/lucide-static@0.483.0/font/lucide.css"
      rel="stylesheet"
    />
    <link
      href="https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:ital,wght@0,100;0,200;0,300;0,400;0,500;0,600;0,700;1,100;1,200;1,300;1,400;1,500;1,600;1,700&display=swap"
      rel="stylesheet"
    />
    <script src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js"></script>
  </head>
  <body>
    <div id="graph-container"></div>
    <div id="gui-container"></div>
    <script src="index.js"></script>
  </body>
</html>
```

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

### Install Ogma via npm or Yarn

Source: https://doc.linkurious.com/ogma/latest/tutorials/typescript/index

Instructions for installing the Ogma library as a dependency in a project using npm or Yarn, either directly from the Linkurious API or from a locally downloaded tar.gz file.

```Shell
npm install --save https://get.linkurio.us/api/get/npm/ogma/<VERSION>/?secret=<YOUR_API_KEY>
# or yarn
yarn add https://get.linkurio.us/api/get/npm/ogma/<VERSION>.tgz?secret=<YOUR_API_KEY>
```

```Shell
npm install --save path/to/ogma-v.X.X.X.tar.gz
```

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

### Start Linkurious Enterprise Docker Container with Volumes

Source: https://doc.linkurious.com/admin-manual/4.2/page

This command starts Linkurious Enterprise in a Docker container, mapping port 3000 and mounting named volumes for persistent data and Elasticsearch storage.

```Dockerfile
 docker run -d --rm \
     -p 3000:3000 \
     --mount type=volume,src=lke-data,dst=/data \
     --mount type=volume,src=lke-elasticsearch,dst=/elasticsearch \
     linkurious:4.2.1
```

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

### Example Single Active Directory Configuration

Source: https://doc.linkurious.com/admin-manual/latest/page

This JSON snippet provides a practical example of configuring a single Microsoft Active Directory service within Linkurious Enterprise, including TLS settings and domain specifications.

```JSON
{
  "access": {
    // [...]
    "msActiveDirectory": {
      "enabled": true,
      "url": "ldaps://ldap.lks.com:636",
      "baseDN": "dc=ldap,dc=lks,dc=com",
      "domain": "ldap.lks.com",
      "netbiosDomain": "LINKURIO",
      "tls": {
        "rejectUnauthorized": true,
        "enableTrace": false
      }
    }
  }
}
```

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

### Initialize Ogma instance: ogma.constructor

Source: https://doc.linkurious.com/ogma/latest/ogma-ai-context.md

Initializes a new Ogma instance, optionally configuring its container, dimensions, initial graph data, image cross-origin settings, general options, and rendering type. This constructor sets up the core visualization environment.

```APIDOC
ogma.constructor([parameters])
  parameters (optional): object
    container (optional): string|HTMLElement - HTML element to use as a container. If a string is specified, the element will be lookup with document.getElementById().
    dimensions (optional): [Size] [default: { width: 300, height: 300 }] - Dimensions of the canvas. If unspecified, the container's dimensions will be used.
    graph (optional): [RawGraph] - Graph to initialize Ogma with
    imgCrossOrigin (optional): [CrossOriginValue] [default: "anonymous"] - Indicates the value of the crossOrigin field for DOM images. This is an alias for ogma.setOptions({imgCrossOrigin: value})
    options (optional): [Options] - Settings for all the modules.
    renderer (optional): "webgl"|"canvas"|"svg"|null [default: "webgl"] - Rendering type. If WebGL is selected and not available, Ogma fallback on Canvas. If no renderer is available (e.g in Node.js), Ogma will fallback on headless mode (null). This field is an alias for ogma.setOptions({renderer: value})
```

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

### API Version Status Endpoint and Example Response

Source: https://doc.linkurious.com/admin-manual/4.2/page

Documents the API endpoint for retrieving the application's version status, including the HTTP method, URL structure, and an example JSON response payload.

```APIDOC
Endpoint: GET /api/version
Description: Retrieves the current API version and status.
Host: 127.0.0.1:3000 (replace with actual host and port)

Example Response:
{
  "tag_name": "4.2.1",
  "name": "Brilliant Burrito",
  "prerelease": false,
  "enterprise": true
}
```

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

### Initialize Ogma Graph Visualization Instance

Source: https://doc.linkurious.com/ogma/latest/tutorials/spanner

Demonstrates how to create a new instance of the Ogma graph visualization library. It specifies the HTML container element where the graph will be rendered, setting up the basic visualization environment.

```ts
import Ogma from '@linkurious/ogma';

const ogma = new Ogma({
  container: 'graph-container',
});
```

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

### Load Graph Data and Initial View Setup

Source: https://doc.linkurious.com/ogma/latest/examples/data-lineage

This asynchronous block handles the initial loading and setup of the graph. It fetches graph data from a JSON file using `Ogma.parse.jsonFromUrl`, then sets this data into the Ogma instance. Following data loading, it adjusts the view to fit the entire graph, saves the initial node coordinates, and populates the reports list for user interaction.

```ts
// Load data from a json file.
const graph = await Ogma.parse.jsonFromUrl<NodeData>('files/datalineage.json');
await ogma.setGraph(graph);
await ogma.view.locateGraph();
await saveCoords();
await fillReports();
```

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

### Create Dedicated Service Account and Set Permissions on Linux

Source: https://doc.linkurious.com/admin-manual/4.2/install

Creates a dedicated 'linkurious' service account with minimal privileges and sets the ownership of the Linkurious Enterprise installation directory to this user, enhancing security.

```bash
useradd -r linkurious
```

```bash
chown -R linkurious:linkurious /linkurious-linux
```

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

### Check Linkurious Server Status with GET /api/status (JavaScript)

Source: https://doc.linkurious.com/server-sdk/latest/page

This snippet demonstrates how to check if the Linkurious Enterprise server is online using the GET /api/status API endpoint. It uses the 'request' library to make an HTTP GET request. The API requires no parameters and returns a JSON object with a 'status.code' field, which should be '200' on success.

```JavaScript
request.get({
uri: 'https://crunchbase.linkurio.us/api/status'
}, function(err, res) {
console.log(res.body);
});
```