NeptuneGraph ************ Client ====== class NeptuneGraph.Client A low-level client representing Amazon Neptune Graph Neptune Analytics is a new analytics database engine for Amazon Neptune that helps customers get to insights faster by quickly processing large amounts of graph data, invoking popular graph analytic algorithms in low-latency queries, and getting analytics results in seconds. import boto3 client = boto3.client('neptune-graph') These are the available methods: * can_paginate * cancel_export_task * cancel_import_task * cancel_query * close * create_graph * create_graph_snapshot * create_graph_using_import_task * create_private_graph_endpoint * delete_graph * delete_graph_snapshot * delete_private_graph_endpoint * execute_query * get_export_task * get_graph * get_graph_snapshot * get_graph_summary * get_import_task * get_paginator * get_private_graph_endpoint * get_query * get_waiter * list_export_tasks * list_graph_snapshots * list_graphs * list_import_tasks * list_private_graph_endpoints * list_queries * list_tags_for_resource * reset_graph * restore_graph_from_snapshot * start_export_task * start_import_task * tag_resource * untag_resource * update_graph Paginators ========== Paginators are available on a client instance via the "get_paginator" method. For more detailed instructions and examples on the usage of paginators, see the paginators user guide. The available paginators are: * ListExportTasks * ListGraphSnapshots * ListGraphs * ListImportTasks * ListPrivateGraphEndpoints Waiters ======= Waiters are available on a client instance via the "get_waiter" method. For more detailed instructions and examples on the usage or waiters, see the waiters user guide. The available waiters are: * ExportTaskCancelled * ExportTaskSuccessful * GraphAvailable * GraphDeleted * GraphSnapshotAvailable * GraphSnapshotDeleted * ImportTaskCancelled * ImportTaskSuccessful * PrivateGraphEndpointAvailable * PrivateGraphEndpointDeleted NeptuneGraph / Waiter / GraphAvailable GraphAvailable ************** class NeptuneGraph.Waiter.GraphAvailable waiter = client.get_waiter('graph_available') wait(**kwargs) Polls "NeptuneGraph.Client.get_graph()" every 60 seconds until a successful state is reached. An error is raised after 480 failed checks. See also: AWS API Documentation **Request Syntax** waiter.wait( graphIdentifier='string', WaiterConfig={ 'Delay': 123, 'MaxAttempts': 123 } ) Parameters: * **graphIdentifier** (*string*) -- **[REQUIRED]** The unique identifier of the Neptune Analytics graph. * **WaiterConfig** (*dict*) -- A dictionary that provides parameters to control waiting behavior. * **Delay** *(integer) --* The amount of time in seconds to wait between attempts. Default: 60 * **MaxAttempts** *(integer) --* The maximum number of attempts to be made. Default: 480 Returns: None NeptuneGraph / Waiter / GraphDeleted GraphDeleted ************ class NeptuneGraph.Waiter.GraphDeleted waiter = client.get_waiter('graph_deleted') wait(**kwargs) Polls "NeptuneGraph.Client.get_graph()" every 60 seconds until a successful state is reached. An error is raised after 60 failed checks. See also: AWS API Documentation **Request Syntax** waiter.wait( graphIdentifier='string', WaiterConfig={ 'Delay': 123, 'MaxAttempts': 123 } ) Parameters: * **graphIdentifier** (*string*) -- **[REQUIRED]** The unique identifier of the Neptune Analytics graph. * **WaiterConfig** (*dict*) -- A dictionary that provides parameters to control waiting behavior. * **Delay** *(integer) --* The amount of time in seconds to wait between attempts. Default: 60 * **MaxAttempts** *(integer) --* The maximum number of attempts to be made. Default: 60 Returns: None NeptuneGraph / Waiter / GraphSnapshotDeleted GraphSnapshotDeleted ******************** class NeptuneGraph.Waiter.GraphSnapshotDeleted waiter = client.get_waiter('graph_snapshot_deleted') wait(**kwargs) Polls "NeptuneGraph.Client.get_graph_snapshot()" every 60 seconds until a successful state is reached. An error is raised after 60 failed checks. See also: AWS API Documentation **Request Syntax** waiter.wait( snapshotIdentifier='string', WaiterConfig={ 'Delay': 123, 'MaxAttempts': 123 } ) Parameters: * **snapshotIdentifier** (*string*) -- **[REQUIRED]** The ID of the snapshot to retrieve. * **WaiterConfig** (*dict*) -- A dictionary that provides parameters to control waiting behavior. * **Delay** *(integer) --* The amount of time in seconds to wait between attempts. Default: 60 * **MaxAttempts** *(integer) --* The maximum number of attempts to be made. Default: 60 Returns: None NeptuneGraph / Waiter / GraphSnapshotAvailable GraphSnapshotAvailable ********************** class NeptuneGraph.Waiter.GraphSnapshotAvailable waiter = client.get_waiter('graph_snapshot_available') wait(**kwargs) Polls "NeptuneGraph.Client.get_graph_snapshot()" every 60 seconds until a successful state is reached. An error is raised after 120 failed checks. See also: AWS API Documentation **Request Syntax** waiter.wait( snapshotIdentifier='string', WaiterConfig={ 'Delay': 123, 'MaxAttempts': 123 } ) Parameters: * **snapshotIdentifier** (*string*) -- **[REQUIRED]** The ID of the snapshot to retrieve. * **WaiterConfig** (*dict*) -- A dictionary that provides parameters to control waiting behavior. * **Delay** *(integer) --* The amount of time in seconds to wait between attempts. Default: 60 * **MaxAttempts** *(integer) --* The maximum number of attempts to be made. Default: 120 Returns: None NeptuneGraph / Waiter / PrivateGraphEndpointDeleted PrivateGraphEndpointDeleted *************************** class NeptuneGraph.Waiter.PrivateGraphEndpointDeleted waiter = client.get_waiter('private_graph_endpoint_deleted') wait(**kwargs) Polls "NeptuneGraph.Client.get_private_graph_endpoint()" every 10 seconds until a successful state is reached. An error is raised after 180 failed checks. See also: AWS API Documentation **Request Syntax** waiter.wait( graphIdentifier='string', vpcId='string', WaiterConfig={ 'Delay': 123, 'MaxAttempts': 123 } ) Parameters: * **graphIdentifier** (*string*) -- **[REQUIRED]** The unique identifier of the Neptune Analytics graph. * **vpcId** (*string*) -- **[REQUIRED]** The ID of the VPC where the private endpoint is located. * **WaiterConfig** (*dict*) -- A dictionary that provides parameters to control waiting behavior. * **Delay** *(integer) --* The amount of time in seconds to wait between attempts. Default: 10 * **MaxAttempts** *(integer) --* The maximum number of attempts to be made. Default: 180 Returns: None NeptuneGraph / Waiter / ExportTaskSuccessful ExportTaskSuccessful ******************** class NeptuneGraph.Waiter.ExportTaskSuccessful waiter = client.get_waiter('export_task_successful') wait(**kwargs) Polls "NeptuneGraph.Client.get_export_task()" every 60 seconds until a successful state is reached. An error is raised after 480 failed checks. See also: AWS API Documentation **Request Syntax** waiter.wait( taskIdentifier='string', WaiterConfig={ 'Delay': 123, 'MaxAttempts': 123 } ) Parameters: * **taskIdentifier** (*string*) -- **[REQUIRED]** The unique identifier of the export task. * **WaiterConfig** (*dict*) -- A dictionary that provides parameters to control waiting behavior. * **Delay** *(integer) --* The amount of time in seconds to wait between attempts. Default: 60 * **MaxAttempts** *(integer) --* The maximum number of attempts to be made. Default: 480 Returns: None NeptuneGraph / Waiter / ImportTaskCancelled ImportTaskCancelled ******************* class NeptuneGraph.Waiter.ImportTaskCancelled waiter = client.get_waiter('import_task_cancelled') wait(**kwargs) Polls "NeptuneGraph.Client.get_import_task()" every 60 seconds until a successful state is reached. An error is raised after 60 failed checks. See also: AWS API Documentation **Request Syntax** waiter.wait( taskIdentifier='string', WaiterConfig={ 'Delay': 123, 'MaxAttempts': 123 } ) Parameters: * **taskIdentifier** (*string*) -- **[REQUIRED]** The unique identifier of the import task. * **WaiterConfig** (*dict*) -- A dictionary that provides parameters to control waiting behavior. * **Delay** *(integer) --* The amount of time in seconds to wait between attempts. Default: 60 * **MaxAttempts** *(integer) --* The maximum number of attempts to be made. Default: 60 Returns: None NeptuneGraph / Waiter / ExportTaskCancelled ExportTaskCancelled ******************* class NeptuneGraph.Waiter.ExportTaskCancelled waiter = client.get_waiter('export_task_cancelled') wait(**kwargs) Polls "NeptuneGraph.Client.get_export_task()" every 60 seconds until a successful state is reached. An error is raised after 60 failed checks. See also: AWS API Documentation **Request Syntax** waiter.wait( taskIdentifier='string', WaiterConfig={ 'Delay': 123, 'MaxAttempts': 123 } ) Parameters: * **taskIdentifier** (*string*) -- **[REQUIRED]** The unique identifier of the export task. * **WaiterConfig** (*dict*) -- A dictionary that provides parameters to control waiting behavior. * **Delay** *(integer) --* The amount of time in seconds to wait between attempts. Default: 60 * **MaxAttempts** *(integer) --* The maximum number of attempts to be made. Default: 60 Returns: None NeptuneGraph / Waiter / ImportTaskSuccessful ImportTaskSuccessful ******************** class NeptuneGraph.Waiter.ImportTaskSuccessful waiter = client.get_waiter('import_task_successful') wait(**kwargs) Polls "NeptuneGraph.Client.get_import_task()" every 60 seconds until a successful state is reached. An error is raised after 480 failed checks. See also: AWS API Documentation **Request Syntax** waiter.wait( taskIdentifier='string', WaiterConfig={ 'Delay': 123, 'MaxAttempts': 123 } ) Parameters: * **taskIdentifier** (*string*) -- **[REQUIRED]** The unique identifier of the import task. * **WaiterConfig** (*dict*) -- A dictionary that provides parameters to control waiting behavior. * **Delay** *(integer) --* The amount of time in seconds to wait between attempts. Default: 60 * **MaxAttempts** *(integer) --* The maximum number of attempts to be made. Default: 480 Returns: None NeptuneGraph / Waiter / PrivateGraphEndpointAvailable PrivateGraphEndpointAvailable ***************************** class NeptuneGraph.Waiter.PrivateGraphEndpointAvailable waiter = client.get_waiter('private_graph_endpoint_available') wait(**kwargs) Polls "NeptuneGraph.Client.get_private_graph_endpoint()" every 10 seconds until a successful state is reached. An error is raised after 180 failed checks. See also: AWS API Documentation **Request Syntax** waiter.wait( graphIdentifier='string', vpcId='string', WaiterConfig={ 'Delay': 123, 'MaxAttempts': 123 } ) Parameters: * **graphIdentifier** (*string*) -- **[REQUIRED]** The unique identifier of the Neptune Analytics graph. * **vpcId** (*string*) -- **[REQUIRED]** The ID of the VPC where the private endpoint is located. * **WaiterConfig** (*dict*) -- A dictionary that provides parameters to control waiting behavior. * **Delay** *(integer) --* The amount of time in seconds to wait between attempts. Default: 10 * **MaxAttempts** *(integer) --* The maximum number of attempts to be made. Default: 180 Returns: None NeptuneGraph / Paginator / ListExportTasks ListExportTasks *************** class NeptuneGraph.Paginator.ListExportTasks paginator = client.get_paginator('list_export_tasks') paginate(**kwargs) Creates an iterator that will paginate through responses from "NeptuneGraph.Client.list_export_tasks()". See also: AWS API Documentation **Request Syntax** response_iterator = paginator.paginate( graphIdentifier='string', PaginationConfig={ 'MaxItems': 123, 'PageSize': 123, 'StartingToken': 'string' } ) Parameters: * **graphIdentifier** (*string*) -- The unique identifier of the Neptune Analytics graph. * **PaginationConfig** (*dict*) -- A dictionary that provides parameters to control pagination. * **MaxItems** *(integer) --* The total number of items to return. If the total number of items available is more than the value specified in max-items then a "NextToken" will be provided in the output that you can use to resume pagination. * **PageSize** *(integer) --* The size of each page. * **StartingToken** *(string) --* A token to specify where to start paginating. This is the "NextToken" from a previous response. Return type: dict Returns: **Response Syntax** { 'tasks': [ { 'graphId': 'string', 'roleArn': 'string', 'taskId': 'string', 'status': 'INITIALIZING'|'EXPORTING'|'SUCCEEDED'|'FAILED'|'CANCELLING'|'CANCELLED'|'DELETED', 'format': 'PARQUET'|'CSV', 'destination': 'string', 'kmsKeyIdentifier': 'string', 'parquetType': 'COLUMNAR', 'statusReason': 'string' }, ], 'NextToken': 'string' } **Response Structure** * *(dict) --* * **tasks** *(list) --* The requested list of export tasks. * *(dict) --* Provides details about an export task. * **graphId** *(string) --* The source graph identifier of the export task. * **roleArn** *(string) --* The ARN of the IAM role that will allow the data to be exported to the destination. * **taskId** *(string) --* The unique identifier of the export task. * **status** *(string) --* The current status of the export task. * **format** *(string) --* The format of the export task. * **destination** *(string) --* The Amazon S3 URI of the export task where data will be exported to. * **kmsKeyIdentifier** *(string) --* The KMS key identifier of the export task. * **parquetType** *(string) --* The parquet type of the export task. * **statusReason** *(string) --* The reason that the export task has this status value. * **NextToken** *(string) --* A token to resume pagination. NeptuneGraph / Paginator / ListGraphSnapshots ListGraphSnapshots ****************** class NeptuneGraph.Paginator.ListGraphSnapshots paginator = client.get_paginator('list_graph_snapshots') paginate(**kwargs) Creates an iterator that will paginate through responses from "NeptuneGraph.Client.list_graph_snapshots()". See also: AWS API Documentation **Request Syntax** response_iterator = paginator.paginate( graphIdentifier='string', PaginationConfig={ 'MaxItems': 123, 'PageSize': 123, 'StartingToken': 'string' } ) Parameters: * **graphIdentifier** (*string*) -- The unique identifier of the Neptune Analytics graph. * **PaginationConfig** (*dict*) -- A dictionary that provides parameters to control pagination. * **MaxItems** *(integer) --* The total number of items to return. If the total number of items available is more than the value specified in max-items then a "NextToken" will be provided in the output that you can use to resume pagination. * **PageSize** *(integer) --* The size of each page. * **StartingToken** *(string) --* A token to specify where to start paginating. This is the "NextToken" from a previous response. Return type: dict Returns: **Response Syntax** { 'graphSnapshots': [ { 'id': 'string', 'name': 'string', 'arn': 'string', 'sourceGraphId': 'string', 'snapshotCreateTime': datetime(2015, 1, 1), 'status': 'CREATING'|'AVAILABLE'|'DELETING'|'FAILED', 'kmsKeyIdentifier': 'string' }, ], 'NextToken': 'string' } **Response Structure** * *(dict) --* * **graphSnapshots** *(list) --* The requested list of snapshots. * *(dict) --* Details about a graph snapshot. * **id** *(string) --* The unique identifier of the graph snapshot. * **name** *(string) --* The snapshot name. For example: "my-snapshot-1". The name must contain from 1 to 63 letters, numbers, or hyphens, and its first character must be a letter. It cannot end with a hyphen or contain two consecutive hyphens. Only lowercase letters are allowed. * **arn** *(string) --* The ARN of the graph snapshot. * **sourceGraphId** *(string) --* The graph identifier for the graph for which a snapshot is to be created. * **snapshotCreateTime** *(datetime) --* The time when the snapshot was created. * **status** *(string) --* The status of the graph snapshot. * **kmsKeyIdentifier** *(string) --* The ID of the KMS key used to encrypt and decrypt the snapshot. * **NextToken** *(string) --* A token to resume pagination. NeptuneGraph / Paginator / ListGraphs ListGraphs ********** class NeptuneGraph.Paginator.ListGraphs paginator = client.get_paginator('list_graphs') paginate(**kwargs) Creates an iterator that will paginate through responses from "NeptuneGraph.Client.list_graphs()". See also: AWS API Documentation **Request Syntax** response_iterator = paginator.paginate( PaginationConfig={ 'MaxItems': 123, 'PageSize': 123, 'StartingToken': 'string' } ) Parameters: **PaginationConfig** (*dict*) -- A dictionary that provides parameters to control pagination. * **MaxItems** *(integer) --* The total number of items to return. If the total number of items available is more than the value specified in max- items then a "NextToken" will be provided in the output that you can use to resume pagination. * **PageSize** *(integer) --* The size of each page. * **StartingToken** *(string) --* A token to specify where to start paginating. This is the "NextToken" from a previous response. Return type: dict Returns: **Response Syntax** { 'graphs': [ { 'id': 'string', 'name': 'string', 'arn': 'string', 'status': 'CREATING'|'AVAILABLE'|'DELETING'|'RESETTING'|'UPDATING'|'SNAPSHOTTING'|'FAILED'|'IMPORTING', 'provisionedMemory': 123, 'publicConnectivity': True|False, 'endpoint': 'string', 'replicaCount': 123, 'kmsKeyIdentifier': 'string', 'deletionProtection': True|False }, ], 'NextToken': 'string' } **Response Structure** * *(dict) --* * **graphs** *(list) --* A list of the graphs. * *(dict) --* Summary details about a graph. * **id** *(string) --* The unique identifier of the graph. * **name** *(string) --* The name of the graph. * **arn** *(string) --* The ARN associated with the graph. * **status** *(string) --* The status of the graph. * **provisionedMemory** *(integer) --* The number of memory-optimized Neptune Capacity Units (m-NCUs) allocated to the graph. * **publicConnectivity** *(boolean) --* If "true", the graph has a public endpoint, otherwise not. * **endpoint** *(string) --* The graph endpoint. * **replicaCount** *(integer) --* The number of replicas for the graph. * **kmsKeyIdentifier** *(string) --* The ID of the KMS key used to encrypt and decrypt graph data. * **deletionProtection** *(boolean) --* If "true", deletion protection is enabled for the graph. * **NextToken** *(string) --* A token to resume pagination. NeptuneGraph / Paginator / ListImportTasks ListImportTasks *************** class NeptuneGraph.Paginator.ListImportTasks paginator = client.get_paginator('list_import_tasks') paginate(**kwargs) Creates an iterator that will paginate through responses from "NeptuneGraph.Client.list_import_tasks()". See also: AWS API Documentation **Request Syntax** response_iterator = paginator.paginate( PaginationConfig={ 'MaxItems': 123, 'PageSize': 123, 'StartingToken': 'string' } ) Parameters: **PaginationConfig** (*dict*) -- A dictionary that provides parameters to control pagination. * **MaxItems** *(integer) --* The total number of items to return. If the total number of items available is more than the value specified in max- items then a "NextToken" will be provided in the output that you can use to resume pagination. * **PageSize** *(integer) --* The size of each page. * **StartingToken** *(string) --* A token to specify where to start paginating. This is the "NextToken" from a previous response. Return type: dict Returns: **Response Syntax** { 'tasks': [ { 'graphId': 'string', 'taskId': 'string', 'source': 'string', 'format': 'CSV'|'OPEN_CYPHER'|'PARQUET'|'NTRIPLES', 'parquetType': 'COLUMNAR', 'roleArn': 'string', 'status': 'INITIALIZING'|'EXPORTING'|'ANALYZING_DATA'|'IMPORTING'|'REPROVISIONING'|'ROLLING_BACK'|'SUCCEEDED'|'FAILED'|'CANCELLING'|'CANCELLED'|'DELETED' }, ], 'NextToken': 'string' } **Response Structure** * *(dict) --* * **tasks** *(list) --* The requested list of import tasks. * *(dict) --* Details about an import task. * **graphId** *(string) --* The unique identifier of the Neptune Analytics graph. * **taskId** *(string) --* The unique identifier of the import task. * **source** *(string) --* A URL identifying to the location of the data to be imported. This can be an Amazon S3 path, or can point to a Neptune database endpoint or snapshot * **format** *(string) --* Specifies the format of S3 data to be imported. Valid values are "CSV", which identifies the Gremlin CSV format or "OPENCYPHER", which identies the openCypher load format. * **parquetType** *(string) --* The parquet type of the import task. * **roleArn** *(string) --* The ARN of the IAM role that will allow access to the data that is to be imported. * **status** *(string) --* Status of the import task. * **NextToken** *(string) --* A token to resume pagination. NeptuneGraph / Paginator / ListPrivateGraphEndpoints ListPrivateGraphEndpoints ************************* class NeptuneGraph.Paginator.ListPrivateGraphEndpoints paginator = client.get_paginator('list_private_graph_endpoints') paginate(**kwargs) Creates an iterator that will paginate through responses from "NeptuneGraph.Client.list_private_graph_endpoints()". See also: AWS API Documentation **Request Syntax** response_iterator = paginator.paginate( graphIdentifier='string', PaginationConfig={ 'MaxItems': 123, 'PageSize': 123, 'StartingToken': 'string' } ) Parameters: * **graphIdentifier** (*string*) -- **[REQUIRED]** The unique identifier of the Neptune Analytics graph. * **PaginationConfig** (*dict*) -- A dictionary that provides parameters to control pagination. * **MaxItems** *(integer) --* The total number of items to return. If the total number of items available is more than the value specified in max-items then a "NextToken" will be provided in the output that you can use to resume pagination. * **PageSize** *(integer) --* The size of each page. * **StartingToken** *(string) --* A token to specify where to start paginating. This is the "NextToken" from a previous response. Return type: dict Returns: **Response Syntax** { 'privateGraphEndpoints': [ { 'vpcId': 'string', 'subnetIds': [ 'string', ], 'status': 'CREATING'|'AVAILABLE'|'DELETING'|'FAILED', 'vpcEndpointId': 'string' }, ], 'NextToken': 'string' } **Response Structure** * *(dict) --* * **privateGraphEndpoints** *(list) --* A list of private endpoints for the specified Neptune Analytics graph. * *(dict) --* Details about a private graph endpoint. * **vpcId** *(string) --* The ID of the VPC in which the private graph endpoint is located. * **subnetIds** *(list) --* The subnet IDs associated with the private graph endpoint. * *(string) --* * **status** *(string) --* The status of the private graph endpoint. * **vpcEndpointId** *(string) --* The ID of the VPC endpoint. * **NextToken** *(string) --* A token to resume pagination. NeptuneGraph / Client / create_graph_snapshot create_graph_snapshot ********************* NeptuneGraph.Client.create_graph_snapshot(**kwargs) Creates a snapshot of the specific graph. See also: AWS API Documentation **Request Syntax** response = client.create_graph_snapshot( graphIdentifier='string', snapshotName='string', tags={ 'string': 'string' } ) Parameters: * **graphIdentifier** (*string*) -- **[REQUIRED]** The unique identifier of the Neptune Analytics graph. * **snapshotName** (*string*) -- **[REQUIRED]** The snapshot name. For example: "my-snapshot-1". The name must contain from 1 to 63 letters, numbers, or hyphens, and its first character must be a letter. It cannot end with a hyphen or contain two consecutive hyphens. Only lowercase letters are allowed. * **tags** (*dict*) -- Adds metadata tags to the new graph. These tags can also be used with cost allocation reporting, or used in a Condition statement in an IAM policy. * *(string) --* * *(string) --* Return type: dict Returns: **Response Syntax** { 'id': 'string', 'name': 'string', 'arn': 'string', 'sourceGraphId': 'string', 'snapshotCreateTime': datetime(2015, 1, 1), 'status': 'CREATING'|'AVAILABLE'|'DELETING'|'FAILED', 'kmsKeyIdentifier': 'string' } **Response Structure** * *(dict) --* * **id** *(string) --* The ID of the snapshot created. * **name** *(string) --* The name of the snapshot created. * **arn** *(string) --* The ARN of the snapshot created. * **sourceGraphId** *(string) --* The Id of the Neptune Analytics graph from which the snapshot is created. * **snapshotCreateTime** *(datetime) --* The snapshot creation time * **status** *(string) --* The current state of the snapshot. * **kmsKeyIdentifier** *(string) --* The ID of the KMS key used to encrypt and decrypt graph data. **Exceptions** * "NeptuneGraph.Client.exceptions.ServiceQuotaExceededException" * "NeptuneGraph.Client.exceptions.ThrottlingException" * "NeptuneGraph.Client.exceptions.ValidationException" * "NeptuneGraph.Client.exceptions.ConflictException" * "NeptuneGraph.Client.exceptions.InternalServerException" * "NeptuneGraph.Client.exceptions.ResourceNotFoundException" NeptuneGraph / Client / create_graph create_graph ************ NeptuneGraph.Client.create_graph(**kwargs) Creates a new Neptune Analytics graph. See also: AWS API Documentation **Request Syntax** response = client.create_graph( graphName='string', tags={ 'string': 'string' }, publicConnectivity=True|False, kmsKeyIdentifier='string', vectorSearchConfiguration={ 'dimension': 123 }, replicaCount=123, deletionProtection=True|False, provisionedMemory=123 ) Parameters: * **graphName** (*string*) -- **[REQUIRED]** A name for the new Neptune Analytics graph to be created. The name must contain from 1 to 63 letters, numbers, or hyphens, and its first character must be a letter. It cannot end with a hyphen or contain two consecutive hyphens. Only lowercase letters are allowed. * **tags** (*dict*) -- Adds metadata tags to the new graph. These tags can also be used with cost allocation reporting, or used in a Condition statement in an IAM policy. * *(string) --* * *(string) --* * **publicConnectivity** (*boolean*) -- Specifies whether or not the graph can be reachable over the internet. All access to graphs is IAM authenticated. ( "true" to enable, or "false" to disable. * **kmsKeyIdentifier** (*string*) -- Specifies a KMS key to use to encrypt data in the new graph. * **vectorSearchConfiguration** (*dict*) -- Specifies the number of dimensions for vector embeddings that will be loaded into the graph. The value is specified as >>``<>``<