Skip to main content
Glama

What is Neptune?

Neptune is an app deployment platform built for AI agents that gives your agents real DevOps abilities. It reads your code, infers the infra it needs, and generates a simple IaC spec you can inspect, approve, and apply. Think: coding agents that can actually ship safely to AWS.

Related MCP server: Synlake MCP Server

Deploy Your First App

Follow the steps below and you can deploy your app in minutes.

Install the Neptune MCP server:

curl -LsSf https://neptune.dev/install.sh | bash

Windows (PowerShell):

irm https://neptune.dev/install.ps1 | iex

Getting Started

For Cursor, go to Cursor Settings -> Tools & MCP -> New MCP Server:

{
    "mcpServers": {
        "neptune": {
            "command": "neptune",
            "args": ["mcp"]
        }
    }
}

Deploy Your App

That's it! Now just tell your agent to deploy your app for you, and Neptune will handle the rest.

Local Development

To test local changes to the MCP server, update your MCP config to point to your local repo:

{
    "mcpServers": {
        "neptune": {
            "type": "stdio",
            "command": "uv",
            "args": [
                "run",
                "--directory",
                "/path/to/neptune-mcp",
                "neptune",
                "mcp"
            ]
        }
    }
}

Replace /path/to/neptune-mcp with the absolute path to your local clone.

After updating the config, restart Cursor (or reload the MCP server) for changes to take effect.

You can also verify the MCP server starts correctly from the terminal:

uv run neptune mcp

Available Tools

15 tools
add_new_resourceA

Get information about resource types that can be provisioned on Neptune.

IMPORTANT: Always use this tool before modifying 'neptune.json'. This is to ensure your modification is correct.

Valid 'kind' are: "StorageBucket" and "Secret".

Inputs: kind (required). Returns: object

delete_projectA

Delete a project and all its resources.

WARNING: This permanently deletes the project and all associated resources including storage buckets and secrets. This action cannot be undone.

Inputs: neptune_json_path (required). Returns: object

deploy_projectA

Deploy the current project.

This only works after the project has been provisioned using 'provision_resources'.

UNDER THE HOOD: this tool builds an image using the Dockerfile in the current directory.

Note: running tasks are not persistent; if the task stops or is redeployed, all data stored in the container is lost. Use provisioned resources (storage buckets, etc.) for persistent data storage.

Inputs: neptune_json_path (required). Returns: object

get_bucket_objectA

Retrieve an object from a storage bucket resource for the current project.

Note the bucket must already exist in the neptune.json configuration of the project. It must also be provisioned using 'provision_resources' before retrieving its objects.

Inputs: key (required), bucket_name (required), neptune_json_path (required). Returns: result

get_deployment_statusB

Get the status of the current deployment of a project and its provisioned resources.

This will tell you about running resources the project is using, as well as the state of the service.

Inputs: neptune_json_path (required). Returns: object

get_logsC

Retrieve the logs for the current project deployment.

Inputs: neptune_json_path (required). Returns: object

get_project_schemaA

Get the JSON schema that defines how to create a valid neptune.json file.

IMPORTANT: Use this tool BEFORE creating or modifying 'neptune.json' to ensure the configuration is valid.

This schema defines the exact structure and constraints for neptune.json files:

  • Required fields (kind, name)

  • Optional fields (resources, port_mappings, cpu, memory)

  • Valid resource types (StorageBucket, Secret) and their properties

  • Allowed values for each field

The returned schema is a standard JSON Schema that you should use as the authoritative reference when generating neptune.json configurations.

Inputs: no named parameters. Returns: object

infoB

Get information about Neptune and available tools for cloud deployment management.

Inputs: no named parameters. Returns: object

list_bucket_filesA

List all files in a storage bucket resource for the current project.

Note the bucket must already exist in the neptune.json configuration of the project. It must also be provisioned using 'provision_resources' before listing its files.

Inputs: bucket_name (required), neptune_json_path (required). Returns: object

list_projectsA

List all projects in the current account.

Inputs: no named parameters. Returns: object

loginA

Authenticate with Neptune.

Opens a browser window for OAuth login. After successful authentication, the access token is saved for use with Neptune tools.

Inputs: no named parameters. Returns: object

provision_resourcesB

Provision necessary cloud resources for the current project as per its configuration

If the working directory does not contain a 'neptune.json' file, an error message is returned.

Inputs: neptune_json_path (required). Returns: object

query_databaseA

Query a database resource for the current project. This will return the results of the query as a dictionary. You can use the 'where_clause' parameter to filter the results of the query. Example:

query_database(neptune_json_path, "users", "age > 18")

This will return the results of the query as a dictionary. You can use the 'table_name' parameter to specify the table to query. Example:

query_database(neptune_json_path, "users", "age > 18")

Note the database must already exist in the neptune.json configuration of the project. It must also be provisioned using 'provision_resources' before querying it.

Inputs: table_name (required), neptune_json_path (required), where_clause. Returns: object

set_secret_valueA

Set the value of a secret resource for the current project.

This will elicit a prompt to securely enter the secret value.

Note the secret must already exist in the neptune.json configuration of the project. It must also be provisioned using 'provision_resources' before setting its value.

Inputs: secret_name (required), neptune_json_path (required). Returns: object

wait_for_deploymentC

Wait for the current project deployment to complete.

Inputs: neptune_json_path (required). Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 15 tools

    Disambiguation4/5

    Most tools have distinct purposes, but wait_for_deployment and get_deployment_status are closely related and add_new_resource's name is misleading (it only returns info about resource types, not actually adding). However, descriptions generally clarify the differences.

    Naming Consistency3/5

    The majority follow a verb_noun pattern (list_projects, get_logs, delete_project), but some deviate: 'info' and 'login' lack objects, and 'add_new_resource' implies an action different from its actual informational purpose. This mixed convention reduces predictability.

    Tool Count4/5

    15 tools is at the high end of the ideal range, but each addresses a distinct aspect of cloud deployment and management. A few informational tools (info, get_project_schema, add_new_resource) are somewhat redundant but still marginally useful.

    Completeness3/5

    Core project operations (list, deploy, delete, status) and resource operations (provision, bucket, secret, database) are covered, but there is no create_project tool, no secret retrieval, and no resource deletion. These gaps may require workarounds.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides AI agents with natural language control over AWS, Azure, GCP, and Alibaba Cloud infrastructure through dynamic API discovery and execution. Supports 51,900+ cloud operations and includes OpenTofu integration for complete infrastructure lifecycle management.
      3
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Enables AI agents to discover, evaluate, and provision cloud infrastructure across AWS, GCP, and Azure with cross-cloud normalization, cost comparisons, and deployable execution kits.
      5
      12 npm
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI agents to deploy code to any hosting provider by creating PRs, building, and verifying health checks, all from a single natural language command.
      55 npm
      1
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      Cloud infrastructure provisioning via natural language. Enables deploying production-ready infrastructure on AWS, GCP, Azure, or Oracle with a single prompt.
      12
      13 npm
      MIT