# ACP Mode
Source: https://docs.augmentcode.com/cli/acp/agent

Auggie is a fully compatible Agent Client Protocol (ACP) agent enabling you to bring the power of Augment to any compatible client.

## About ACP Mode

[Agent Client Protocol](https://agentclientprotocol.com/overview/introduction) (ACP) is an open protocol that provides a standardized way to connect AI agents to different text editors, IDEs, and other tools. ACP mode uses JSON-RPC over standard input and output to communicate between the agent and the client. You can see a [overview of the protocol](https://agentclientprotocol.com/protocol/overview) to learn more.

## Using ACP Mode

To use Auggie in ACP mode, you need to pass the `--acp` flag when starting Auggie. You can pass additional [command-line arguments](/cli/reference) to set the model, authentication, and other options.

```sh theme={null}
auggie --acp
```

To use Auggie in a ACP-compatible client, you need to configure the client to launch Auggie with the `--acp` flag and follow the client-specific instructions. See the [ACP Clients](/cli/acp/clients) page for more details.

## Compatibility

ACP is an emerging protocol and is in active development. Not all features available in interactive mode are supported in ACP mode. We are looking forward to working with the community to add support for more features in the future.


# ACP Clients
Source: https://docs.augmentcode.com/cli/acp/clients

Configure Auggie to run in any Agent Client Protocol (ACP) compatible client like Zed, Neovim, or Emacs.

## About ACP Clients

[Agent Client Protocol](https://agentclientprotocol.com/overview/introduction) (ACP) is an open protocol that provides a standardized way to connect AI agents to different text editors, IDEs, and other tools. Auggie is a fully ACP compatible agent enabling you to bring the power of Augment to editors like Zed, Neovim, or Emacs. See a [full list of supported clients](https://agentclientprotocol.com/overview/clients) in the ACP docs.

## Prerequisites

* Auggie CLI [installed and configured](/cli/setup-auggie/install-auggie-cli)
* Login to Augment with `auggie login`
* A compatible ACP client

## Client configuration

If you have an ACP client that you would like to have listed here, please [open an issue](https://github.com/augmentcode/auggie/issues/new) and we'll be happy to add it.

### Zed

<Note>
  We recommend installing and configuring Auggie in [Zed](https://zed.dev/) using the [Auggie extension](https://zed.dev/extensions/auggie).
</Note>

If you want to configure Auggie manually through Zed's settings, you can use the following configuration. You can pass additional [command-line arguments](/cli/reference) to Auggie by adding them to the `args` array or use alternative [authentication methods](/cli/setup-auggie/authentication) by passing environment variables in the `env` object.

```
{
  "agent_servers": {
    "Auggie CLI": {
      "command": "auggie",
      "args": ["--acp"],
      "env": {}
    }
  }
}
```

### JetBrains

<Note>
  We recommend installing and configuring Augment in [JetBrains IDEs](/jetbrains/setup-augment/install-jetbrains-ides) using the [Augment extension](https://plugins.jetbrains.com/plugin/24072-augment-ai-coding-assistant-for-professionals).
</Note>

To use Auggie with JetBrains IDEs, you can configure it in your IDE settings. You can pass additional [command-line arguments](/cli/reference) to Auggie by adding them to the `args` array or use alternative [authentication methods](/cli/setup-auggie/authentication) by passing environment variables in the `env` object.

```json theme={null}
{
  "agent_servers": {
    "Auggie CLI": {
      "command": "/path/to/auggie",
      "args": [
        "--acp"
      ],
      "env": {}
    }
  }
}
```

### Neovim

To use Auggie with neovim, you can use one of the following plugins:

* [CodeCompanion](https://github.com/olimorris/codecompanion.nvim)
* [Avante](https://github.com/yetone/avante.nvim?tab=readme-ov-file#enabling-acp)

### Emacs

To use Auggie with emacs, you can use one of the following plugins:

* [agent-shell.el](https://github.com/xenodium/agent-shell)


# Using Auggie with Automation
Source: https://docs.augmentcode.com/cli/automation/overview

Auggie was designed to not just be a powerful agent to write code, but to automate all the tasks that are needed to build software at scale.

## About automation

Auggie was purpose built to integrate into your software development stack. From using Auggie in your local development workflows to automatically running Auggie in your CI/CD pipelines, Auggie can help you build better software faster.

### Example use cases

* **Code reviews**: Review code changes and provide feedback.
* **Issue triage**: Triage incoming issues and route them to the appropriate team or individual.
* **Automate on-call**: Respond to incoming alerts and create an assessment plan.
* **Exception management**: Analyze incoming exceptions and create tickets.

## Integrating with your workflows

In order to use Auggie in your systems, like a CI/CD pipeline, you'll need to install Auggie CLI, provide a session token, and write an instruction that will be used alongside any data from your system you want to include.

### Installation

Auggie can be [installed](/cli/setup-auggie/install-auggie-cli) directly from npm anywhere you can run Node 22 or later including VMs, serverless functions, and containers. You will also need to install any dependencies for defined MCP servers in those environments.

```sh theme={null}
npm install -g @augmentcode/auggie
```

### Authentication

Session tokens are associated with the user that created it, and Auggie will run with integration configurations from that user. See [Authentication](/cli/setup-auggie/authentication) for full details. You can override the user's GitHub configuration by passing `--github-api-token <token>`.

```sh theme={null}
# First, login to Augment with the CLI
auggie login

# Next, output your token
auggie tokens print

# Then, pass your token to auggie
AUGMENT_SESSION_AUTH='<token>' auggie --print "Summarize the build failure"
```

### Scripts and pipes

Auggie runs as a subprocess, so it can be used in any shell script. It can be used just like any command-line tool that follows the Unix philosophy. You can pipe data into Auggie and then pipe the response to another command. Data passed into Auggie through stdin will be used as context in addition to the instruction.

```sh theme={null}
# Pipe data through stdin
cat build.log | auggie --print "Summarize the failure and open a Linear ticket"

# Provide input from a file
auggie --compact --instruction /path/to/instruction.md < build.log
```

## GitHub Actions

GitHub Actions makes it easy to connect Auggie to other parts of your software development pipeline, from linting, testing, build, and deploy. We've built a [simple wrapper for Auggie](https://github.com/augmentcode/augment-agent) that enables you to  integrate with GitHub Action workflows and build custom tooling around Auggie.

Follow the instructions to [configure Augment Agent](https://github.com/augmentcode/augment-agent/blob/main/README.md) in GitHub Actions and explore the [example-workflows](https://github.com/augmentcode/augment-agent/tree/main/example-workflows) directory to get started.

### Ready to use workflows

Get started using Auggie in GitHub Actions immediately by following the instructions for setup and deploy in one of the following workflows, or use the `/github-workflow` wizard in Auggie to have the workflows generated for you.

* [PR Description](https://github.com/augmentcode/describe-pr): This action automatically analyzes your PR changes and generates comprehensive, informative descriptions.
* [PR Review](https://github.com/augmentcode/review-pr): This action automatically analyzes your PR changes and generates comprehensive, informative reviews

Need even more help building GitHub Actions? May we suggest asking Auggie.

```sh theme={null}
auggie "Help me build a GitHub Action to..."
```


# Service Accounts
Source: https://docs.augmentcode.com/cli/automation/service-accounts



## About

Service Accounts provide non-human identities for automation use cases to make API requests to the Augment backend through Auggie CLI. They decouple automation tasks from using individual user accounts and enable per-automation task token lifecycle management.

## Managing Service Accounts

Service Accounts can be managed by navigating to [app.augmentcode.com/settings/service-accounts](https://app.augmentcode.com/settings/service-accounts) and logging in. Service accounts are only available to [Enterprise plan](https://augmentcode.com/pricing) customers. Service accounts can only be managed by the Administrator of the Enterprise Plan.

### Creating a Service Account

To create a new service account, click the "New Service Account" button. You will be prompted to enter a name and an optional description for the service account. The account name must be unique within your organization.

### Creating API tokens

Once you've created a service account, you can create API tokens for it by clicking the "Add API token" button next to the service account name in the list of service accounts. You will be prompted to enter a name for the API token which must be unique amongst the tokens for this service account. Once you've created a token, you will be given a one time opportunity to retrieve the token value by either:

* Copying the token value directly or using the "Copy token" button **OR**
* Downloading a `session.json` file that is ready to use with Auggie CLI.

API tokens for service accounts don't have an expiration date and need to be manually revoked if they are no longer needed.

### Deleting Service Accounts and API tokens

API tokens can be revoked by selecting "Revoke" from the triple dot menu next to the token name in the service account list. Note that revoking a token is a permanent action and cannot be undone. Any existing Auggie CLI automation sessions using the token will be disrupted.

Service accounts can be deleted by clicking "Manage" next to the service account name in the service account list, and then clicking "Delete Account" from the dialog that appears. Note that deleting a service account will also delete all the associated API tokens.

## Using API tokens with Auggie CLI

In order to use a service account API token with Auggie CLI, you need to edit the `session.json` file stored under `~/.augment`. If you've downloaded a `session.json` file after creating the API token, you can simply replace the existing `session.json` file with the new one. If you've only copied the token value, you need to edit the `session.json` file with the following content and replace the `accessToken` value with the new token value.

```
{
  "accessToken": "<TOKEN VALUE>",
  "tenantURL": "<TENANT URL>",
  "scopes": [
    "read",
    "write"
  ]
}
```

The correct `tenantURL` value for your organization is displayed on top of the service account list in the management UI.

## Best Practices

* Use a separate service account per automation task. This will allow you to manage token lifecycle and monitor credit usage per automation task.
* Use the ability to create multiple tokens under a service account to rotate tokens when needed. Create a new API token, update the automation tasks to use the new token, and revoke the old token once all automation tasks have been updated.


# Automatic Updates
Source: https://docs.augmentcode.com/cli/autoupgrade

Learn how to manage and troubleshoot Auggie CLI's automatic update feature.

## How Automatic Updates Work

Auggie CLI automatically updates itself when running in interactive mode to ensure you always have the latest features and bug fixes.

### Interactive Mode (TUI)

* Automatically checks npm for newer versions when you start Auggie
* Performs upgrades without prompting to minimize interruption
* Shows a brief notification when an update is applied
* Best-effort approach - continues running even if update fails

### Non-interactive Mode (Print/Text Mode)

* Auto-update is completely disabled
* Respects version pinning in automation scripts

## Disabling Automatic Updates

Set the `AUGMENT_DISABLE_AUTO_UPDATE` environment variable to `1` to disable automatic updates.

### Environment Variable (Recommended for Scripts)

```bash theme={null}
# Disable for current session
export AUGMENT_DISABLE_AUTO_UPDATE=1

# Disable for single command
AUGMENT_DISABLE_AUTO_UPDATE=1 auggie --print "Your instruction here"
```

## Manual Updates

You can manually update Auggie CLI by running the following command.

```bash theme={null}
auggie upgrade
```


# Custom Slash Commands
Source: https://docs.augmentcode.com/cli/custom-commands

Create and manage custom slash commands for frequently-used prompts and workflows.

## About Custom Slash Commands

Custom slash commands let you create reusable prompts stored as Markdown files that Auggie can run. You can organize commands by scope (workspace or user) and use directory structures for namespacing.

### Syntax

```
/<command-name> [arguments]
```

### Parameters

| Parameter        | Description                              |
| :--------------- | :--------------------------------------- |
| `<command-name>` | Name derived from the Markdown filename  |
| `[arguments]`    | Optional arguments passed to the command |

## Command Types and Locations

Custom commands are stored in markdown files and can be placed in multiple locations with a specific order of precedence:

### Command Locations (in order of precedence)

1. **User Commands**: `~/.augment/commands/<name>.md` (user)
2. **Workspace Commands**: `./.augment/commands/<name>.md` (workspace)
3. **Claude Code Commands**: `./.claude/commands/<name>.md` (.claude)

### User Commands

Commands available across all your projects. These are user-wide and persist across different workspaces.

**Location**: `~/.augment/commands/`

```sh theme={null}
# Create a global command
mkdir -p ~/.augment/commands
echo "Review this code for security vulnerabilities:" > ~/.augment/commands/security-review.md
```

### Workspace Commands

Commands stored in your repository and shared with your team. These are workspace-specific and can be committed to version control.

**Location**: `./.augment/commands/`

```sh theme={null}
# Create a workspace command
mkdir -p .augment/commands
echo "Analyze this code for performance issues and suggest optimizations:" > .augment/commands/optimize.md
```

### Claude Code Compatibility

Auggie automatically detects and supports commands from `./.claude/commands/` for compatibility with existing Claude Code setups. This allows teams already using Claude Code to continue using their existing command libraries without modification.

**Location**: `./.claude/commands/` and `~/.claude/commands/`

**Migration**: While `./.claude/commands/` is supported for compatibility, we recommend migrating to `./.augment/commands/` for new projects to maintain consistency with Auggie's naming conventions.

## Features

### Namespacing

Organize commands in subdirectories. Commands from nested directories can be accessed using the `namespace:command` syntax, where the namespace corresponds to the subdirectory name.

For example, a file at `.augment/commands/frontend/component.md` creates the command `/frontend:component`.

Conflicts between user and workspace level commands are not supported and will be defined in order of precedence above.

### Arguments

Pass dynamic values to commands.

```markdown theme={null}
# Command definition
echo 'Fix issue following our coding standards' > .augment/commands/fix-issue.md

# Usage
> /fix-issue 123
```

### Frontmatter

Command files support frontmatter for metadata:

| Frontmatter     | Purpose                                                                    | Default                             |
| :-------------- | :------------------------------------------------------------------------- | :---------------------------------- |
| `description`   | Brief description of the command                                           | Uses the first line from the prompt |
| `argument-hint` | Expected arguments format that will be displayed after typing in a command | None                                |
| `model`         | Specify the model to run this command with (overrides the CLI default)     | Uses the CLI default model          |

**File**: `~/.augment/commands/deploy-staging.md`

```markdown theme={null}
---
description: Deploy the application to staging with health checks
argument-hint: [branch-name]
model: gpt-4o
---

Deploy the application to the staging environment:

1. Run all tests to ensure code quality
2. Build the application for production
3. Deploy to staging server
4. Run health checks to verify deployment
5. Send notification to team channel
```

## Command Line Execution

We also provide the ability to execute custom commands from the command line using the `auggie command <your_command>` or list them with `auggie command list`. For complete command-line reference, see [CLI Reference for Custom Commands](/cli/reference#custom-commands).

```sh theme={null}
# Execute a custom command
auggie command deploy-staging

# List all available commands (including custom ones)
auggie command list
```

Custom commands appear in the help output with their descriptions:

```
Available custom commands:
  auggie command deploy-staging    # Deploy the application to staging
  auggie command security-review   # Review code for security vulnerabilities
```

## Example Commands

For ready-to-use examples of custom slash commands, including code review templates, bug fix guides, and feature implementation plans, see:

**[Custom Commands Examples](/cli/custom-commands-examples)**

## Best Practices

1. **Use kebab-case naming** for command names (e.g., `deploy-staging`, `run-tests`)
2. **Keep names descriptive** but concise, avoiding spaces and special characters
3. **Use meaningful prefixes** for related commands (e.g., `deploy-staging`, `deploy-production`)
4. **Include clear descriptions** in frontmatter for better discoverability
5. **Break complex workflows** into numbered steps for clarity
6. **Use user commands** (`~/.augment/commands/`) for personal workflows across all projects
7. **Use workspace commands** (`./.augment/commands/`) for team-shared, project-specific tasks
8. **Organize with subdirectories** for related command groups using namespacing
9. **Document command purpose** and expected outcomes clearly
10. **Version your commands** when making significant changes

## See Also

* [Custom Commands Examples](/cli/custom-commands-examples) - Ready-to-use command templates and examples
* [Interactive Mode Slash Commands](/cli/interactive#slash-commands) - Learn about Auggie's interactive terminal features
* [CLI Reference for Custom Commands](/cli/reference#custom-commands) - Complete reference for command-line flags


# Custom Slash Commands Examples
Source: https://docs.augmentcode.com/cli/custom-commands-examples

Ready-to-use examples of custom slash commands for common development workflows.

## Example Commands

Here are some practical examples of custom slash commands you can use in your projects:

<AccordionGroup>
  <Accordion title="Code Review Command">
    ```markdown theme={null}
    ---
    description: Perform a comprehensive code review
    argument-hint: [file-path]
    ---

    Please perform a comprehensive code review of the specified file or current changes, focusing on:

    1. **Code Quality**: Check for readability, maintainability, and adherence to best practices
    2. **Security**: Look for potential security vulnerabilities
    3. **Performance**: Identify potential performance issues
    4. **Testing**: Suggest areas that need test coverage
    5. **Documentation**: Check if code is properly documented

    $ARGUMENTS
    ```
  </Accordion>

  <Accordion title="Bug Fix Template">
    ```markdown theme={null}
    ---
    description: Generate a structured bug fix approach
    argument-hint: [bug-description]
    ---

    Help me fix this bug: $ARGUMENTS

    Please provide:
    1. Root cause analysis
    2. Step-by-step fix approach
    3. Testing strategy
    4. Prevention measures for similar issues
    ```
  </Accordion>

  <Accordion title="Feature Implementation Guide">
    ```markdown theme={null}
    ---
    description: Create implementation plan for new features
    argument-hint: [feature-description]
    ---

    Create a detailed implementation plan for: $ARGUMENTS

    Include:
    - Technical requirements
    - Architecture considerations
    - Implementation steps
    - Testing approach
    - Documentation needs
    ```
  </Accordion>

  <Accordion title="Security Review Command">
    ```markdown theme={null}
    ---
    description: Perform security analysis on code
    argument-hint: [file-path]
    ---

    Perform a security review of: $ARGUMENTS

    Focus on:
    1. **Input validation** and sanitization
    2. **Authentication** and authorization checks
    3. **Data exposure** and privacy concerns
    4. **Injection vulnerabilities** (SQL, XSS, etc.)
    5. **Cryptographic** implementations
    6. **Dependencies** with known vulnerabilities

    Provide specific recommendations for any issues found.
    ```
  </Accordion>

  <Accordion title="Performance Optimization">
    ```markdown theme={null}
    ---
    description: Analyze and optimize code performance
    argument-hint: [file-path]
    ---

    Analyze the performance of: $ARGUMENTS

    Please examine:
    1. **Algorithm complexity** and efficiency
    2. **Memory usage** patterns
    3. **Database queries** and optimization opportunities
    4. **Caching** strategies
    5. **Network requests** and bundling
    6. **Rendering performance** (for frontend code)

    Suggest specific optimizations with expected impact.
    ```
  </Accordion>

  <Accordion title="Documentation Generator">
    ```markdown theme={null}
    ---
    description: Generate comprehensive documentation
    argument-hint: [file-path]
    ---

    Generate documentation for: $ARGUMENTS

    Include:
    1. **Overview** and purpose
    2. **API reference** with parameters and return values
    3. **Usage examples** with code snippets
    4. **Configuration options** if applicable
    5. **Error handling** and troubleshooting
    6. **Dependencies** and requirements

    Format as clear, structured markdown.
    ```
  </Accordion>

  <Accordion title="Test Generation Command">
    ```markdown theme={null}
    ---
    description: Generate comprehensive test cases
    argument-hint: [file-path]
    ---

    Generate test cases for: $ARGUMENTS

    Create tests covering:
    1. **Happy path** scenarios
    2. **Edge cases** and boundary conditions
    3. **Error handling** and exceptions
    4. **Integration points** with other components
    5. **Performance** considerations
    6. **Security** edge cases

    Use appropriate testing framework conventions and include setup/teardown as needed.
    ```
  </Accordion>
</AccordionGroup>

## How to Add Commands to Your Project

To use these custom slash commands in your project, you need to save them in the `.augment/commands/` directory:

### Step 1: Create the Commands Directory

First, create the `.augment/commands/` directory in your project root if it doesn't exist:

```bash theme={null}
mkdir -p .augment/commands
```

### Step 2: Save Command Files

Save each command as a separate `.md` file in the `.augment/commands/` directory. For example:

```bash theme={null}
# Save the code review command
cat > .augment/commands/code-review.md << 'EOF'
---
description: Perform a comprehensive code review
argument-hint: [file-path]
---

Please perform a comprehensive code review of the specified file or current changes, focusing on:

1. **Code Quality**: Check for readability, maintainability, and adherence to best practices
2. **Security**: Look for potential security vulnerabilities
3. **Performance**: Identify potential performance issues
4. **Testing**: Suggest areas that need test coverage
5. **Documentation**: Check if code is properly documented

$ARGUMENTS
EOF
```

### Step 3: Use Your Commands

Once saved, your custom commands become available as slash commands in Augment:

```
/code-review src/components/Button.tsx
/bug-fix "Login form validation not working"
/security-review auth/middleware.js
```

### Directory Structure

Your project structure should look like this:

```
your-project/
├── .augment/
│   └── commands/
│       ├── code-review.md
│       ├── bug-fix.md
│       ├── security-review.md
│       └── performance-optimization.md
├── src/
└── package.json
```

## Usage Tips

* **Save these templates** in your `.augment/commands/` directory
* **Customize the prompts** to match your team's coding standards and practices
* **Add project-specific context** to make the commands more effective
* **Combine commands** by referencing outputs from one command in another
* **Use meaningful filenames** like `code-review.md`, `bug-fix.md`, etc.
* **Version control your commands** by committing the `.augment/commands/` directory to your repository

## Creating Your Own Examples

When creating custom commands, consider these patterns:

1. **Start with a clear description** in the frontmatter
2. **Use argument hints** to guide users on expected inputs
3. **Structure your prompts** with numbered lists or bullet points
4. **Include specific instructions** for the type of analysis or output you want
5. **Reference the `$ARGUMENTS` variable** where user input should be inserted

## See Also

* [Custom Slash Commands](/cli/custom-commands) - Learn how to create and manage custom commands
* [CLI Reference for Custom Commands](/cli/reference#custom-commands) - Complete command-line reference for custom commands


# Integrations and MCP
Source: https://docs.augmentcode.com/cli/integrations

Expand Augment's capabilities with external tools and data sources through native integrations and Model Context Protocol (MCP) servers.

<Note>Auggie runs commands and tools automatically. Only use integrations and MCP servers from trusted sources, and be aware of the risks of combining multiple tools with external data sources or production systems.</Note>

## About Integrations and MCP

Auggie can utilize external integrations through native integrations like GitHub, Linear, and Notion and Model Context Protocol (MCP) to access external systems for information and integrate tools to take actions. MCP is an open protocol that provides a standardized way to connect AI models to different data sources and tools.

## Native Integrations

You'll need to configure the integration in Augment for VS Code or JetBrains IDEs. Once configured, the integration will be available for use with Auggie automatically. See a full list and examples for [native agent integrations](/setup-augment/agent-integrations).

### 1. Setup in Augment extension

* **Visual Studio Code**: Click the settings icon in the top right of Augment's chat window or press <Keyboard /> and select <Command />
* **JetBrains IDEs**: Click the Augment icon in the bottom right of your JetBrains IDE and select <Command />

### 2. Connect the integration

Click "Connect" for the integration you want to set up

<img alt="Set up integrations in the settings page" />

You'll be redirected to authorize the integration with the appropriate service. After authorization, the integration will be available for use with Augment Agent.

## MCP Integrations

In addition to native integrations, Auggie can also access external systems through Model Context Protocol (MCP) servers. MCP servers enable Auggie to interact with external tools and services through a standardized protocol, such as accessing databases, running browser automation, sending messages to Slack, or integrating with APIs.

### Configure MCP via settings.json

You can persist MCP servers in the Augment settings file `~/.augment/settings.json`, which will initialize on startup and can be checked with `/mcp-status`.

```json theme={null}
{
  "mcpServers": {
    "context7": {
      "type": "http",
      "url": "https://mcp.context7.com/mcp",
      "headers": {
        "CONTEXT7_API_KEY": "YOUR_API_KEY"
      }
    },
    "weather": {
      "type": "sse",
      "url": "https://weather-mcp.example.com/v1",
      "headers": {
        "X-API-Key": "your_weather_api_key",
        "Content-Type": "application/json"
      }
    },
    "renderMCP": {
      "type": "http",
      "url": "https://mcp.render.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    },
    "local-tool": {
      "command": "/usr/local/bin/custom-mcp",
      "args": ["--serve", "--port", "3000"],
      "env": { "DEBUG": "true" }
    }
  }
}
```

#### HTTP Transport with Headers

MCP servers using HTTP transport can include a `headers` object for authentication or custom headers:

```json theme={null}
{
  "mcpServers": {
    "renderMCP": {
      "type": "http",
      "url": "https://mcp.render.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>",
        "X-Custom-Header": "custom-value"
      }
    }
  }
}
```

The `headers` field accepts any valid HTTP headers as key-value pairs.

**Common uses**

* **Authentication** - `Authorization` headers with bearer tokens or API keys
* **Custom parameters** - Server-specific information that doesn't fit into standard request parameters
* **Session management** - `Mcp-Session-Id` header for managing sessions in Streamable HTTP transport

**Considerations**

* **Transport type** - Headers are relevant for HTTP and SSE transports only. Stdio transport uses standard input/output and does not use HTTP headers
* **Server requirements** - Required headers depend on the MCP server implementation
* **Security** - Avoid including sensitive information like API keys directly in configuration files. Consider secure credential management methods

### Manage MCP servers with the Auggie CLI

You can add and inspect MCP servers is via Auggie subcommands, which will persist the configuration to your `~/.augment/settings.json` file:

#### Usage

**Add MCP server:**

```bash theme={null}
auggie mcp add <name> [options]
```

Writes the server entry to your settings.json with interactive prompts for overwriting existing configurations.

Options:

* `--command <path>` - Executable path (for stdio transport)
* `--args <args>` - Arguments string for command
* `-e, --env <KEY=VAL>` - Environment variable (repeatable)
* `-t, --transport <transport>` - stdio|sse|http (default: "stdio")
* `-u, --url <url>` - URL (required for --transport sse or http)
* `-h, --header <KEY:VAL>` - HTTP header (repeatable, for http transport)
* `-r, --replace` - Overwrite existing entry without prompt
* `--json` - Output JSON

**Add MCP server from JSON:**

```bash theme={null}
auggie mcp add-json <name> <json>
```

Import an MCP server configuration directly from a JSON string. This is useful when you have a complete server configuration in JSON format and want to add it quickly without specifying individual options.

The JSON string should match the structure used in `settings.json` for MCP server configurations. This command uses the same mechanism as `--mcp-config` but provides a convenient way to add servers directly from the command line.

**List MCP servers:**

```bash theme={null}
auggie mcp list [options]
```

Lists configured MCP servers (from settings and any active overrides).

Options:

* `--json` - Output JSON format

**Remove MCP server:**

```bash theme={null}
auggie mcp remove <name> [options]
```

Cleanly removes the named server configuration from settings.json.

Examples:

```bash theme={null}
# Add a stdio-based MCP server (executable with args and environment)
auggie mcp add context7 \
  --command npx \
  --args "-y @upstash/context7-mcp@latest" \
  --env CONTEXT7_API_KEY=your_key

# Compressed syntax 
auggie mcp add context7 -- npx -y @upstash/context7-mcp

# Add an SSE-based MCP server (Server-Sent Events with URL)
auggie mcp add weather-api \
  --transport sse \
  --url https://weather-mcp.example.com/sse

# Compressed syntax
auggie mcp add weather-api --transport sse https://weather-mcp.example.com/sse

# Add an HTTP-based MCP server with authentication headers
auggie mcp add renderMCP \
  --transport http \
  --url https://mcp.render.com/mcp \
  --header "Authorization:Bearer YOUR_API_TOKEN"

# Add HTTP server with multiple headers
auggie mcp add api-service \
  --transport http \
  --url https://api.example.com/mcp \
  --header "Authorization:Bearer YOUR_TOKEN" \
  --header "X-Custom-Header:custom-value"

# List all configured servers (tabular display with status)
auggie mcp list

# List servers in JSON format for programmatic access
auggie mcp list --json

# Remove a server configuration
auggie mcp remove context7

# Replace existing server without interactive prompt
auggie mcp add context7 --command npx --args "..." --replace

# Add MCP server from JSON configuration (stdio transport)
auggie mcp add-json weather-api '{"type":"stdio","command":"/path/to/weather-cli","args":["--api-key","abc123"],"env":{"CACHE_DIR":"/tmp"}}'

# Add MCP server from JSON configuration (SSE transport)
auggie mcp add-json remote-api '{"type":"sse","url":"https://api.example.com/sse"}'

# Add MCP server from JSON configuration (HTTP transport with headers)
auggie mcp add-json renderMCP '{"type":"http","url":"https://mcp.render.com/mcp","headers":{"Authorization":"Bearer ABC_XYZ_123"}}'
```

### MCP overrides

You can define servers by passing ad‑hoc overrides with `--mcp-config`. The structure is the same as `settings.json`:

```json theme={null}
// After npm install gitlab-mr-mcp
{
  "mcpServers": {
    "gitlab-mr-mcp": {
      "command": "node",
      "args": ["/path/to/gitlab-mr-mcp/index.js"],
      "env": {
        "MR_MCP_GITLAB_TOKEN": "your_gitlab_token",
        "MR_MCP_GITLAB_HOST": "your_gitlab_host"
      }
    }
  }
}
```


# Interactive mode
Source: https://docs.augmentcode.com/cli/interactive

Use a rich interactive terminal experience to explore your codebase, build new features, debug issues, and integrate your tools.

<Note>Auggie is currently in beta and does not support all features available in the Augment plugins for Visual Studio Code or JetBrains IDEs.</Note>

## About interactive mode

Auggie is an agentic terminal-based code assistant that has deep codebase knowledge powered by Augment's context engine. Auggie can help you understand a new codebase, fix bugs quickly, and build new features faster. Auggie has access to your connected integrations and MCP servers and can pull in additional context or run tools to get your tasks done.

## Using interactive mode

Run `auggie` without any mode flags to get the full-screen terminal user interface with rich interactive features, real-time streaming of responses, and visual progress indicators. This mode shows all tool calls, results, and allows ongoing conversation through an intuitive interface.

```sh theme={null}
# Start Auggie in interactive mode
auggie

# Provide an initial instruction
auggie "Look at my open issues and prioritize the highest impact ones for me"
```

### Multi-line input

Entering a new line in the input box depends on your terminal configuration and platform. You can use `Ctrl + J` to enter a new line in any terminal. See below for instructions to configure your terminal to use `Option + Enter` to enter a new line.

| Terminal application       | New line shortcut |
| :------------------------- | :---------------- |
| All terminals              | `Ctrl + J`        |
| MacOS Terminal (see below) | `Option + Enter`  |
| iTerm2 (see below)         | `Option + Enter`  |
| VS Code Terminal           | `Option + Enter`  |
| Ghostty                    | `Shift + Enter`   |

**MacOS Terminal**

1. Go to <Command />
2. Check <Command />

**iTerm2**

1. Go to <Command />
2. Check <Command />

## Reference

### Shortcuts

| Command             | Description                                                 |
| :------------------ | :---------------------------------------------------------- |
| `Ctrl + P`          | Enhance your prompt with codebase context                   |
| `Escape`            | Interrupt the active agent                                  |
| `Ctrl + C`          | Interrupt the active agent                                  |
| `Escape` + `Escape` | Clear the input box                                         |
| `Ctrl + C`          | Press twice to exit                                         |
| `Ctrl + D`          | Press twice to exit                                         |
| `Up Arrow`          | Cycle through previous messages                             |
| `Down Arrow`        | Cycle through previous messages                             |
| `Ctrl + O`          | Open current input in external editor, inserts text on exit |

### Slash Commands

| Command            | Description                                                 |
| :----------------- | :---------------------------------------------------------- |
| `/account`         | Show account information                                    |
| `/clear`           | Clear the input box                                         |
| `/editor`          | Open current input in external editor, inserts text on exit |
| `/exit`            | Exit Auggie                                                 |
| `/feedback`        | Provide feedback to the Augment team                        |
| `/github-workflow` | Generate a GitHub Action workflow                           |
| `/help`            | Show help                                                   |
| `/logout`          | Logout of Augment                                           |
| `/mcp-status`      | View the status of all configured MCP servers               |
| `/model`           | Select the model for this session                           |
| `/new`             | Start a new conversation with no message history            |
| `/permissions`     | View and manage tool permissions                            |
| `/request-id`      | Show the request ID for the current conversation            |
| `/task`            | Open task manager to add, edit, and manage tasks            |
| `/verbose`         | Toggle verbose output for tools                             |
| `/vim`             | Toggle Vim mode for advanced text editing                   |

For more information about slash commands, including how to create custom commands, see [Custom Slash Commands](/cli/custom-commands).


# Prompt Enhancer
Source: https://docs.augmentcode.com/cli/interactive/prompt-enhancer

Use Ctrl+P to enhance your prompts with relevant context, structure, and conventions from your codebase.

## About the Prompt Enhancer

The Auggie CLI prompt enhancer is a powerful feature that helps you craft better prompts by automatically adding relevant context, structure, and conventions from your codebase. Instead of writing detailed prompts from scratch, you can start with a simple idea and let the prompt enhancer transform it into a comprehensive, well-structured prompt.

## Activating the Prompt Enhancer

To use the prompt enhancer in Auggie's interactive mode:

1. **Start typing your prompt** in the input box
2. **Press <Keyboard />** to activate the prompt enhancer
3. **Wait for enhancement** - Auggie will process your prompt and replace it with an enhanced version
4. **Review and edit** the enhanced prompt if needed
5. **Submit your enhanced prompt** by pressing Enter

<Note>The prompt enhancer is only available when you have text entered at the command prompt. The <Keyboard /> shortcut will only work in interactive mode.</Note>

## How It Works

When you press <Keyboard />, the prompt enhancer:

1. **Captures your current input** and saves it to history
2. **Switches to Enhancement mode** - you'll see the mode indicator change and input will be temporarily disabled
3. **Sends your prompt** to the enhancement service using your current workspace context
4. **Processes the response** and extracts the enhanced prompt
5. **Replaces your input** with the enhanced version and returns to Normal mode

During enhancement, you'll see:

* The mode indicator shows "Enhancing your prompt, press Esc to cancel"
* Input is disabled to prevent conflicts
* A visual indication that processing is in progress

## Enhancement Process

The prompt enhancer uses your workspace context to improve your prompts by:

* **Adding relevant file references** from your current project
* **Including coding conventions** and patterns from your codebase
* **Structuring the prompt** for better clarity and specificity
* **Adding context** about your project's architecture and dependencies
* **Suggesting specific examples** based on existing code patterns

## Canceling Enhancement

You can cancel the prompt enhancement process at any time:

* **Press <Keyboard />** to cancel enhancement and restore your original input
* **Press <Keyboard />** to cancel enhancement and restore your original input

When canceled, you'll see a brief notification and your original prompt will be restored.

## Error Handling

If the prompt enhancement fails:

* Your original input will be restored
* An error notification will appear briefly (\~3 seconds)
* You can try enhancing again or proceed with your original prompt

Common reasons for enhancement failure:

* Network connectivity issues
* Service temporarily unavailable
* Input too short or unclear for enhancement

## Examples

### Before Enhancement

```
fix the login bug
```

### After Enhancement (Example)

```
Fix the authentication bug in the login flow. Please:

1. Review the current login implementation in `src/auth/login.ts`
2. Check for issues with token validation and session management
3. Examine error handling in the authentication middleware
4. Look at recent changes to the user authentication flow
5. Test the fix with both valid and invalid credentials
6. Ensure the fix follows our existing error handling patterns

Context: This appears to be related to the recent changes in the authentication system. Please maintain consistency with our existing auth patterns and ensure proper error messages are returned to the user.
```

## Integration with Other Features

The prompt enhancer works seamlessly with other Auggie CLI features:

* **History Navigation**: Enhanced prompts are added to your command history
* **Multi-line Input**: Works with both single-line and multi-line prompts
* **Conversation Context**: Uses your current conversation history for better enhancement
* **Workspace Awareness**: Leverages your current workspace and file context

## Tips for Best Results

1. **Start with clear intent** - Even simple prompts like "add tests" or "refactor this" work well
2. **Be specific about scope** - Mention specific files or components when relevant
3. **Use domain language** - Technical terms related to your project help the enhancer understand context
4. **Review enhanced prompts** - The enhancer provides a starting point; feel free to edit further
5. **Iterate if needed** - You can enhance the same prompt multiple times for different approaches

## Troubleshooting

**Ctrl+P doesn't work:**

* Ensure you have text in the input box
* Make sure you're in Normal mode (not in a menu or other mode)
* Check that you're using the correct key combination for your terminal

**Enhancement takes too long:**

* Press Esc to cancel and try again
* Check your network connection
* Try with a shorter or simpler prompt

**Enhanced prompt isn't helpful:**

* Edit the enhanced prompt manually
* Try starting with a more specific initial prompt
* Consider the context - the enhancer works best with workspace-relevant requests

## Related Features

* [Task Management](/cli/interactive/task-management) - Break down enhanced prompts into manageable tasks
* [Keyboard Shortcuts](/cli/interactive#shortcuts) - Learn other useful CLI shortcuts
* [Slash Commands](/cli/interactive#slash-commands) - Discover other interactive commands


# Using Task Manager
Source: https://docs.augmentcode.com/cli/interactive/task-management

Use /task to break down complex problems into manageable steps.

## About the Task Manager

The Auggie CLI task manager allows you to break down complex problems into discrete, manageable actions and track your progress through each step. It's particularly useful for automation workflows and keeping the agent focused on multi-step tasks.

The task manager maintains state per session and stores tasks under `~/.augment` for persistence across CLI sessions.

## Activating the Task Manager

Start Auggie in interactive mode and use the `/task` slash command:

```bash theme={null}
# Start Auggie in interactive mode
auggie

# Then type the slash command
/task
```

This opens the task manager interface, which takes over the main panel and provides a focused environment for task management.

### Alternative Access

You can also ask the agent to create a task list for you:

```bash theme={null}
auggie "Start a task list to implement user authentication"
```

The agent will automatically create and populate a task list when it encounters complex, multi-step problems.

## Task Manager Interface

The task manager provides a scrollable interface with comprehensive theming and visual feedback. When active, it replaces the main chat interface to provide a focused task management experience.

### Navigation and Interaction

Use your keyboard to interact with the Task Manager:

| Key        | Action                                                                                     |
| :--------- | :----------------------------------------------------------------------------------------- |
| `↑` / `↓`  | Navigate between tasks. The active task is highlighted with • next to the \[ ] Task Title. |
| `J` / `K`  | Alternative vim-style navigation (up/down)                                                 |
| `A`        | Add a new task                                                                             |
| `E`        | Edit the active task's title and description                                               |
| `D`        | Delete the active task                                                                     |
| `Spacebar` | Toggle task status                                                                         |
| `Esc`      | Dismiss the Task Manager                                                                   |

## Task Status Indicators

Tasks have three distinct states with corresponding visual status indicators:

* **\[ ] Not Started** - Empty checkbox, task has not been started
* **\[✓] Done** - Checkmark, task has been completed
* **\[-] Cancelled** - Dash, task has been cancelled or is no longer needed

## Working with Tasks

### Creating Tasks

**Manual Creation:**

1. Press `A` to add a new task
2. Enter the task title when prompted
3. Optionally add a description for more detailed context

**Agent-Generated Tasks:**
The agent automatically creates tasks inside the Task Manager when it encounters complex problems. You can also explicitly request task creation:

```bash theme={null}
"Create a task list to refactor the authentication system"
```

### Editing Tasks

1. Navigate to the desired task using arrow keys or J/K
2. Press `E` to edit
3. Modify the title first, then the description
4. The task manager provides inline editing with clear visual feedback

### Task Execution

**Manual Execution:**

* Use the task list as a checklist, manually updating status as you complete work
* Toggle status with `Spacebar` to track progress

**Agent Execution:**
You can ask the agent to work on specific tasks from the task manager:

```bash theme={null}
"Work on the first incomplete task in my task list"
"Complete the database migration task"
```

The agent will access your task list and update task status as it works.

## Advanced Features

### Task Hierarchy and Subtasks

The task manager supports nested task structures:

* Main tasks can have subtasks for complex workflows
* Subtasks are automatically indented and organized hierarchically
* Navigate through nested structures using standard navigation keys

### Persistence and Sessions

* Tasks are automatically saved per session under `~/.augment`
* Task lists persist across CLI restarts within the same session
* Each conversation session maintains its own task list

### Integration with Agent Workflow

The task manager is designed to work seamlessly with agent automation:

* **Keeps agents focused**: Provides clear structure for multi-step workflows
* **Progress tracking**: Agent can update task status as it completes work
* **Context preservation**: Tasks maintain context across long conversations
* **Automation-friendly**: Particularly useful for non-interactive automation workflows

## Use Cases and Examples

### Development Workflow

```bash theme={null}
auggie "Create a task list to implement user registration feature"
# Agent creates tasks like:
# [ ] Design user registration API endpoints
# [ ] Create user model and database schema
# [ ] Implement registration validation
# [ ] Add password hashing and security
# [ ] Write unit tests for registration
# [ ] Update API documentation
```

### Code Refactoring

```bash theme={null}
auggie "Break down refactoring the payment system into tasks"
# Agent creates structured tasks for complex refactoring
```

### Bug Investigation

```bash theme={null}
auggie "Create tasks to investigate and fix the login timeout issue"
# Agent creates systematic debugging tasks
```

## Tips for Effective Task Management

1. **Be Specific**: Create clear, actionable task descriptions
2. **Break Down Complex Work**: Use subtasks for multi-step processes
3. **Regular Updates**: Keep task status current for accurate progress tracking
4. **Agent Collaboration**: Let the agent help create and organize task structures
5. **Session Organization**: Use task lists to maintain focus across long sessions

## Troubleshooting

**Task Manager Won't Open:**

* Ensure you're in interactive mode (`auggie` without `-p` flag)
* Try typing `/task` exactly as shown
* Check that you're not in the middle of another operation

**Tasks Not Persisting:**

* Tasks are saved per session - starting a new session creates a new task list
* Check that `~/.augment` directory has proper write permissions

**Navigation Issues:**

* Use either arrow keys (↑/↓) or vim keys (J/K) for navigation
* Ensure the task manager has focus (not in edit mode)

## Related Features

* [Prompt Enhancer](/cli/interactive/prompt-enhancer) - Enhance task descriptions with context
* [Keyboard Shortcuts](/cli/interactive#shortcuts) - Learn other useful CLI shortcuts
* [Slash Commands](/cli/interactive#slash-commands) - Discover other interactive commands


# Introducing Auggie CLI
Source: https://docs.augmentcode.com/cli/overview

Auggie in the terminal gives you powerful agentic capabilities to analyze code, make changes, and execute tools in an interactive terminal and in your automated workflows.

## Introduction

<CardGroup>
  <Card title="GitHub Repository" icon="github" href="https://github.com/augmentcode/auggie">
    Report issues, leave feature requests and view custom workflows for Auggie CLI
  </Card>

  <Card title="NPM Package" icon="npm" href="https://www.npmjs.com/package/@augmentcode/auggie">
    Install Auggie CLI from npm
  </Card>
</CardGroup>

Auggie CLI takes the power of Augment's agent and context engine and puts it in your terminal, allowing you to use Augment anywhere your code goes. You can use Auggie in a standalone interactive terminal session alongside your favorite editor or in any part of your software development stack.

* Build features and debug issues with a standalone interactive agent.
* Get instant feedback, insight, and suggestions for your PRs and builds.
* Triage customer issues and alerts from your observability stack.

## Getting started

To use Auggie CLI in interactive mode or in your automations, you'll need:

* Node 22 or later installed
* A compatible shell like zsh, bash, fish

<Steps>
  <Step title="Install Auggie with npm">
    ```sh theme={null}
    npm install -g @augmentcode/auggie
    ```

    You can install Auggie CLI directly from npm anywhere you can run Node 22 or later. Auggie is currently in beta and may not run on all environments and terminal configurations.
  </Step>

  <Step title="Go to your project directory">
    ```sh theme={null}
    cd /path/to/your/project
    ```

    Your project will be indexed automatically when you run Auggie in your project directory. Augment's powerful context engine provides the best results when it has access to your project's codebase and any related repositories.
  </Step>

  <Step title="Login or sign up to Augment">
    ```sh theme={null}
    auggie login
    ```

    After installing, you'll have to log in to your Augment account. Run auggie login and follow the prompts.
  </Step>

  <Step title="Start using Auggie">
    ```sh theme={null}
    auggie "optional initial prompt"
    ```

    Just run `auggie` to start the interactive terminal. You can also pass a prompt as an argument and use `--print` to print the response to stdout instead of the interactive terminal–perfect for automation workflows.
  </Step>
</Steps>

## Using Auggie in interactive mode

Run `auggie` without any mode flags to get the full-screen terminal user interface with rich interactive features, real-time streaming of responses, and visual progress indicators. This mode shows all tool calls, results, and allows ongoing conversation through an intuitive interface.

Best for manual development work, exploration, and interactive problem-solving sessions where you want the full visual experience and plan to have back-and-forth conversations with the agent.

## Using Auggie in your automations

**Print Mode**: Add the `--print` flag (e.g., `auggie --print "your instruction"`) to execute the instruction once without the UI. This mode exits immediately without prompting for additional input. Perfect for automation, CI/CD pipelines, and background tasks where you want the agent to act without follow-up from a person.

**Quiet Mode**: `--quiet` flag (e.g., `auggie --print --quiet "your instruction"`) to tell the agent to only reply back with a final output. Ideal when you need to use the agent to provide structured data back without all the steps it took to get there. Provides a simple, clean response.


# Tool Permissions
Source: https://docs.augmentcode.com/cli/permissions

Control what tools Auggie CLI can execute with granular permission settings for security and compliance. Tool permissions configured will only work inside the CLI and not in the Augment code extension.

## About Tool Permissions

Auggie CLIs tool permission system provides fine-grained control over what actions the agent can perform in your environment. This security layer ensures that Auggie only executes approved operations, protecting your codebase and system from unintended changes.

Tool permissions are especially important when:

* Running Auggie in production environments
* Working with sensitive codebases
* Enforcing organizational security policies
* Using Auggie in automated workflows

## How Permissions Work

When Auggie attempts to use a tool, the permission system:

1. **Checks for matching rules** in your configuration
2. **Applies the first matching rule** based on tool name and optional patterns
3. **Rules are evaluated top-down** - first match wins
4. **Prompts for approval** when set to ask-user mode (interactive only)

### Permission Flow

```
Tool Request → Check Rules → Apply Permission → Execute/Deny → Log Decision
```

### Notes on Unmatched Tools

* Rules are evaluated in order from top to bottom
* The first matching rule determines the permission
* If no rules match, the CLI follows its implicit runtime behavior
* Configure explicit rules for all tools you want to control

## Configuration Files

Tool permissions are configured through the `settings.json` located in `~/.augment/settings.json` as personal settings that apply to all your projects.

## Basic Configuration

### Creating Rules

Rules define permissions for specific tools. Each rule can specify:

* **Tool name** - The specific tool to control
* **Permission type** - `allow`, `deny`, or `ask-user`
* **Optional patterns** - For shell commands, use regex matching

### Basic Rule Structure

```json theme={null}
{
  "toolPermissions": [
    { "toolName": "launch-process", "permission": { "type": "deny" } },
    { "toolName": "view", "permission": { "type": "allow" } }
  ]
}
```

### Allow List Configuration

Create an explicit allow list by only allowing specific tools:

```json theme={null}
{
  "toolPermissions": [
    { "toolName": "view", "permission": { "type": "allow" } },
    { "toolName": "codebase-retrieval", "permission": { "type": "allow" } },
    { "toolName": "grep-search", "permission": { "type": "allow" } },
    { "toolName": "github-api", "permission": { "type": "allow" } }
  ]
}
```

<Note>This configuration explicitly allows only the listed tools. Tools not in this list will follow the CLI's implicit behavior.</Note>

### Block List Configuration

Create a block list by explicitly denying specific dangerous tools:

```json theme={null}
{
  "toolPermissions": [
    { "toolName": "remove-files", "permission": { "type": "deny" } },
    { "toolName": "kill-process", "permission": { "type": "deny" } },
    { "toolName": "launch-process", "shellInputRegex": "^(rm|sudo|shutdown|reboot)", "permission": { "type": "deny" } }
  ]
}
```

<Note>This configuration blocks specific dangerous operations. Tools not explicitly denied will follow the CLI's implicit behavior.</Note>

### Mix and Match Configuration

Combine allow, deny, and ask-user rules for fine-grained control:

```json theme={null}
{
  "toolPermissions": [
    { "toolName": "view", "permission": { "type": "allow" } },
    { "toolName": "codebase-retrieval", "permission": { "type": "allow" } },
    { "toolName": "grep-search", "permission": { "type": "allow" } },

    { "toolName": "str-replace-editor", "permission": { "type": "ask-user" } },
    { "toolName": "save-file", "permission": { "type": "ask-user" } },

    { "toolName": "launch-process", "shellInputRegex": "^(npm test|npm run lint|git status|git diff)", "permission": { "type": "allow" } },
    { "toolName": "launch-process", "shellInputRegex": "^(rm -rf|sudo|chmod 777)", "permission": { "type": "deny" } },
    { "toolName": "launch-process", "permission": { "type": "ask-user" } },

    { "toolName": "remove-files", "permission": { "type": "deny" } }
  ]
}
```

This configuration provides fine-grained control with different permission levels based on tool risk and usage patterns.

## Available Tools

### Process Management

| Tool             | Description                        |
| :--------------- | :--------------------------------- |
| `launch-process` | Execute shell commands and scripts |
| `read-process`   | Read output from running processes |
| `write-process`  | Send input to running processes    |
| `list-processes` | List all active processes          |
| `kill-process`   | Terminate running processes        |

### File Operations

| Tool                 | Description                         |
| :------------------- | :---------------------------------- |
| `view`               | Read file contents                  |
| `str-replace-editor` | Edit files with find/replace        |
| `save-file`          | Create or overwrite files           |
| `remove-files`       | Delete files from the filesystem    |
| `codebase-retrieval` | Search codebase with context engine |
| `grep-search`        | Search files with regex patterns    |

### External Services

| Tool         | Description                  |
| :----------- | :--------------------------- |
| `github-api` | GitHub API operations        |
| `linear`     | Linear issue tracking        |
| `notion`     | Notion workspace access      |
| `supabase`   | Supabase database operations |
| `web-search` | Web search queries           |
| `web-fetch`  | Fetch web page content       |

### MCP Server Tools

MCP tools follow the pattern `{tool-name}_{server-name}`:

* Example: `query_database-mcp`
* Truncated to 64 characters if longer
* Treated like any other tool for permissions

## Advanced Rules

### Shell Command Filtering

Control which shell commands can be executed using regex patterns:

```json theme={null}
{
  "toolPermissions": [
    { "toolName": "launch-process", "shellInputRegex": "^(ls|pwd|echo|cat|grep)\\s", "permission": { "type": "allow" } },
    { "toolName": "launch-process", "permission": { "type": "deny" } }
  ]
}
```

This configuration:

1. Allows only safe commands (ls, pwd, echo, cat, grep)
2. Denies all other shell commands
3. Rules are evaluated in order - first match wins

### Event-Based Permissions

Control when permission checks occur:

```json theme={null}
{
  "toolPermissions": [
    { "toolName": "github-api", "eventType": "tool-response", "permission": { "type": "allow" } }
  ]
}
```

**Event types:**

* **`tool-call`** (default) - Check before tool execution
* **`tool-response`** - Check after execution but before returning results to agent

## Interactive Approval

When using `ask-user` mode in interactive sessions, Auggie displays approval prompts:

```
🔒 Tool Approval Required
─────────────────────────
Tool: launch-process
Command: npm install express

[A]llow once  [D]eny  [Always allow]  [Never allow]
```

### Keyboard Shortcuts

| Key   | Action                      |
| :---- | :-------------------------- |
| `A`   | Allow this specific request |
| `D`   | Deny this specific request  |
| `Y`   | Always allow this tool      |
| `N`   | Never allow this tool       |
| `Esc` | Cancel and deny request     |

<Note>In non-interactive mode (--print), ask-user permissions default to deny for security.</Note>

## Common Configurations

### Read-Only Mode

Allow only read operations, perfect for code review and analysis:

```json theme={null}
{
  "toolPermissions": [
    { "toolName": "view", "permission": { "type": "allow" } },
    { "toolName": "codebase-retrieval", "permission": { "type": "allow" } },
    { "toolName": "grep-search", "permission": { "type": "allow" } },
    { "toolName": "web-search", "permission": { "type": "allow" } },
    { "toolName": "web-fetch", "permission": { "type": "allow" } },
    { "toolName": "str-replace-editor", "permission": { "type": "deny" } },
    { "toolName": "save-file", "permission": { "type": "deny" } },
    { "toolName": "remove-files", "permission": { "type": "deny" } },
    { "toolName": "launch-process", "permission": { "type": "deny" } }
  ]
}
```

### Development Mode

Add safety guards for potentially dangerous operations:

```json theme={null}
{
  "toolPermissions": [
    { "toolName": "remove-files", "permission": { "type": "ask-user" } },
    {
      "toolName": "launch-process",
      "shellInputRegex": "^(rm|sudo|chmod)\\s",
      "permission": { "type": "ask-user" }
    }
  ]
}
```

### CI/CD Pipeline

Restrictive settings for automated workflows:

```json theme={null}
{
  "toolPermissions": [
    { "toolName": "view", "permission": { "type": "allow" } },
    { "toolName": "str-replace-editor", "permission": { "type": "allow" } },
    { "toolName": "save-file", "permission": { "type": "allow" } },
    {
      "toolName": "launch-process",
      "shellInputRegex": "^(npm test|npm run lint|jest)\\s",
      "permission": { "type": "allow" }
    },
    { "toolName": "remove-files", "permission": { "type": "deny" } },
    { "toolName": "launch-process", "permission": { "type": "deny" } }
  ]
}
```

## Custom Policies

### Webhook Validation

Use external services to validate tool requests:

```json theme={null}
{
  "toolPermissions": [
    { "toolName": "github-api", "permission": { "type": "webhook-policy", "webhookUrl": "https://api.company.com/validate-tool" } }
  ]
}
```

The webhook receives a POST request with the following JSON payload:

```json theme={null}
{
  "tool-name": "github-api",
  "event-type": "tool-call",
  "details": { /* tool-specific data, see below */ },
  "timestamp": "2025-01-01T02:41:40.580Z"
}
```

**Payload fields:**

* **`tool-name`**: The name of the tool being invoked
* **`event-type`**: Either `"tool-call"` (before execution) or `"tool-response"` (after execution)
* **`details`**: Tool-specific data (for `tool-call`) or response data (for `tool-response`)
* **`timestamp`**: ISO 8601 timestamp of the request

**Details for `tool-call` event type** (varies by tool):

| Tool                 | Details Fields    |
| :------------------- | :---------------- |
| `launch-process`     | `cwd`, `command`  |
| `view`               | `path`            |
| `str-replace-editor` | `path`, `command` |
| `save-file`          | `path`            |
| `remove-files`       | `file_paths`      |
| `web-fetch`          | `url`             |

**Details for `tool-response` event type:**

```json theme={null}
{
  "text": "Tool output text",
  "isError": false
}
```

**Expected response:**

```json theme={null}
{
  "allow": true,
  "output": "Optional message to include in agent response"
}
```

### Script Validation

Use local scripts for complex validation logic:

```json theme={null}
{
  "toolPermissions": [
    { "toolName": "launch-process", "permission": { "type": "script-policy", "script": "/path/to/validate-command.sh" } }
  ]
}
```

The script receives the same JSON payload as webhooks via **stdin**:

```json theme={null}
{
  "tool-name": "launch-process",
  "event-type": "tool-call",
  "details": {
    "cwd": "/path/to/workspace",
    "command": "npm install express"
  },
  "timestamp": "2025-01-01T02:41:40.580Z"
}
```

**Script behavior:**

* **Exit code 0**: Allow the tool execution
* **Non-zero exit code**: Deny the tool execution
* **stdout/stderr**: Optional message included in the agent response

**Example script:**

```bash theme={null}
#!/bin/bash
# Read JSON payload from stdin
payload=$(cat)

# Extract command using jq
command=$(echo "$payload" | jq -r '.details.command // empty')

# Deny dangerous commands
if [[ "$command" == *"rm -rf"* ]] || [[ "$command" == *"sudo"* ]]; then
  echo "Dangerous command blocked: $command"
  exit 1
fi

# Allow all other commands
exit 0
```

## Best Practices

1. **Be Explicit**: Define clear rules for all tools you want to control
2. **Test Configurations**: Verify permissions work as expected before automation
3. **Log Decisions**: Monitor which tools are being allowed/denied for audit trails
4. **Regular Reviews**: Periodically review and update permission rules
5. **Order Matters**: Remember that rules are evaluated top-down, first match wins

## Troubleshooting

**Ask-User Mode in Automation:**

* Ask-user permissions automatically deny in non-interactive mode
* Use explicit allow/deny rules for automation scenarios
* Consider webhook or script policies for dynamic decisions

**MCP Tools Not Recognized:**

* Ensure MCP server name follows `{tool}_{server}` pattern
* Check for 64-character truncation on long names
* Verify MCP server is properly configured and running

## Security Considerations

* **Never commit sensitive webhook URLs** to version control
* **Use `.augment/settings.local.json`** for personal security overrides
* **Regularly audit** tool usage in production environments
* **Implement defense in depth** with multiple permission layers
* **Test permission changes** in isolated environments first

## Related Features

* [Authentication](/cli/setup-auggie/authentication) - Secure access to Auggie
* [Custom Rules](/cli/rules) - Project-specific guidelines
* [MCP Integrations](/cli/integrations) - External tool configuration
* [Automation](/cli/automation) - Using permissions in CI/CD


# CLI Flags and Options
Source: https://docs.augmentcode.com/cli/reference

A comprehensive reference for all command-line flags available in the Auggie CLI.

## CLI flags

| Command                          | Description                                                                                                                                                          |
| :------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `auggie`                         | Start Auggie in interactive mode                                                                                                                                     |
| `auggie --print` (`-p`)          | Output simple text for one instruction and exit                                                                                                                      |
| `auggie --quiet`                 | Output only the final response for one instruction and exit                                                                                                          |
| `auggie --compact`               | Output tool calls, results, and final response as one line each and exit                                                                                             |
| `auggie -p --output-format json` | Output the response in structured JSON format. Must be used with `--print` (`-p`) mode. Useful for parsing Auggie's output programmatically in automation workflows. |

### Input

| Command                                            | Description                                        |
| :------------------------------------------------- | :------------------------------------------------- |
| `auggie "Fix the typescript errors"`               | Provide an initial instruction in interactive mode |
| `auggie --print "Summarize the staged changes"`    | Provide an instruction and exit                    |
| `cat file \| auggie --print "Summarize this data"` | Pipe content through stdin                         |
| `auggie --print "Summarize this data" < file.txt`  | Provide input from a file                          |
| `auggie --instruction "Fix the errors"`            | Provide an initial instruction in interactive mode |
| `auggie --instruction-file /path/to/file.txt`      | Provide an instruction by file in interactive mode |

### Custom Commands

| Command                         | Description                                                                  |
| :------------------------------ | :--------------------------------------------------------------------------- |
| `auggie command <command-name>` | Execute a custom command from `.augment/commands/` or `~/.augment/commands/` |

Custom commands are reusable instructions stored as markdown files. They can be placed in:

* `~/.augment/commands/<name>.md` - Global commands (user-wide)
* `./.augment/commands/<name>.md` - Project commands (workspace-specific)
* `~/.claude/commands/<name>.md` - Claude Code user commands
* `./.claude/commands/<name>.md` - Claude Code workspace commands

Commands are resolved in order of precedence, with Auggie-specific locations taking priority over Claude Code locations.

**Examples:**

```sh theme={null}
# Execute a custom deployment command
auggie command deploy-staging

# Execute a code review command
auggie command security-review

# List available commands (shown in help output)
auggie command help
```

See [Custom Commands](/cli/custom-commands) for detailed information on creating and managing custom commands.

### Sessions

| Command                          | Description                                       |
| :------------------------------- | :------------------------------------------------ |
| `auggie --continue` `(-c)`       | Resumes the previous conversation                 |
| `auggie --dont-save-session`     | Do not save the conversation to the local history |
| `auggie --delete-saved-sessions` | Delete all saved sessions from disk               |

### Configuration

| Command                                    | Description                                                               |
| :----------------------------------------- | :------------------------------------------------------------------------ |
| `auggie --workspace-root /path/to/project` | Specify the root of the workspace                                         |
| `auggie --rules /path/to/rules.md`         | Additional rules to append to workspace guidelines                        |
| `auggie --model "name"`                    | Select the model to use (accepts long or short names from the model list) |

### Models

List out available models and their short names to be passed into the `--model` flag

| Command              | Description           |
| :------------------- | :-------------------- |
| `auggie models list` | List available models |

### Tools

Manage which tools are available to the agent. You can temporarily disable tools for a session or persistently manage them via settings.

| Command                            | Description                                                                              |
| :--------------------------------- | :--------------------------------------------------------------------------------------- |
| `auggie --remove-tool <tool-name>` | Remove a specific tool by name for the current session. Can be specified multiple times. |
| `auggie tools list`                | List all available tools and their current status                                        |
| `auggie tools remove <tool-name>`  | Persistently remove a tool by adding it to the `removedTools` list in settings.json      |
| `auggie tools add <tool-name>`     | Re-enable a previously removed tool by removing it from the `removedTools` list          |

**Examples:**

```sh theme={null}
# Disable the web-fetch tool for this session
auggie --remove-tool web-fetch

# Disable multiple tools for this session
auggie --remove-tool web-fetch --remove-tool web-search

# Persistently disable a tool
auggie tools remove launch-process

# Re-enable a previously disabled tool
auggie tools add launch-process

# See all tools and their status
auggie tools list
```

<Note>Command-line `--remove-tool` flags take precedence over settings. For fine-grained control over tool behavior (allow, deny, ask-user), see [Permissions](/cli/permissions).</Note>

### MCP and integrations

| Command                             | Description                                       |
| :---------------------------------- | :------------------------------------------------ |
| `auggie mcp add [options] <name>`   | Create or update a named MCP server configuration |
| `auggie mcp add-json <name> <json>` | Add an MCP server from JSON configuration         |
| `auggie mcp list`                   | Display all configured MCP servers                |
| `auggie mcp remove <name>`          | Remove a named MCP server configuration           |

| Command                                 | Description                        |
| :-------------------------------------- | :--------------------------------- |
| `auggie --mcp-config {key: value}`      | MCP configuration as a JSON string |
| `auggie --mcp-config /path/to/mcp.json` | MCP configuration from a JSON file |

<Note>You can define MCP servers persistently in the settings files: `~/.augment/settings.json`. Any `--mcp-config` flags are applied last and override settings.</Note>

For detailed usage examples, options, settings.json format, and precedence rules, see [Integrations and MCP](/cli/integrations#manage-mcp-servers-with-the-auggie-cli).

### MCP Server Mode

Run Auggie as an MCP server to expose the codebase-retrieval tool to external AI tools like Claude Code, Cursor, and others.

| Flag                   | Description                                                                                       |
| :--------------------- | :------------------------------------------------------------------------------------------------ |
| `--mcp`                | Run Auggie as an MCP tool server. Uses the current working directory as the workspace by default. |
| `--mcp-auto-workspace` | Enable automatic workspace discovery based on client requests (added in v0.14.0)                  |
| `-w /path/to/project`  | Specify a workspace to index                                                                      |

#### Automatic Workspace Discovery

The `--mcp-auto-workspace` flag enables dynamic workspace discovery in MCP mode. When enabled:

* The `codebase-retrieval` tool accepts a `directory_path` parameter to specify which workspace to search
* Workspaces are indexed on-demand when first accessed
* Multiple workspaces can be searched within a single MCP server session

This is useful when the MCP client (e.g., Claude Code) needs to work with multiple projects or when the workspace isn't known at startup time.

You can combine `--mcp-auto-workspace` with `-w` to pre-index a primary workspace at startup while still allowing dynamic discovery of additional workspaces. This is useful for large workspaces that take time to index, or to reduce latency on the first query to your main project.

**Examples:**

```bash theme={null}
# MCP server with auto-discovery (recommended)
auggie --mcp --mcp-auto-workspace

# Pre-index a workspace, allow dynamic discovery of others
auggie --mcp --mcp-auto-workspace -w /path/to/primary/project

# Use only a single workspace path
auggie --mcp -w /path/to/project

# Use current working directory as the workspace
auggie --mcp
```

<Note>When using `--mcp-auto-workspace`, the first query to a new workspace may take longer as the workspace is indexed. Subsequent queries to the same workspace will be fast.</Note>

### Authentication

| Command               | Description                                  |
| :-------------------- | :------------------------------------------- |
| `auggie login`        | Login to Augment and store the token locally |
| `auggie logout`       | Remove the locally stored token              |
| `auggie tokens print` | Print the locally stored token               |

### Additional commands

| Command            | Description  |
| :----------------- | :----------- |
| `auggie --help`    | Show help    |
| `auggie --version` | Show version |

## Environment Variables

| Variable                      | Description                   |
| ----------------------------- | ----------------------------- |
| `AUGMENT_SESSION_AUTH`        | Authentication JSON.          |
| `AUGMENT_API_URL`             | Backend API endpoint          |
| `AUGMENT_API_TOKEN`           | Authentication token          |
| `GITHUB_API_TOKEN`            | GitHub API token              |
| `AUGMENT_DISABLE_AUTO_UPDATE` | Disable automatic CLI updates |

### Shell Environment

When Auggie executes shell commands using the `launch-process` tool, it sets the following environment variable:

| Variable        | Description                                                                                                                        |
| --------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| `AUGMENT_AGENT` | Set to `1` when a command is executed by Auggie. Scripts can check for this variable to detect if they are being run by the agent. |

**Example usage in a script:**

```sh theme={null}
if [ -n "$AUGMENT_AGENT" ]; then
  echo "Running inside Auggie"
  # Adjust behavior for agent execution
fi
```

## See Also

* [Custom Rules and Guidelines](/cli/rules) - Configure custom rules for project-specific guidance
* [Custom Commands](/cli/custom-commands) - Create reusable command templates
* [Permissions](/cli/permissions) - Configure tool permissions and security
* [Integrations](/cli/integrations) - Connect external tools and services


# Rules & Guidelines
Source: https://docs.augmentcode.com/cli/rules

Configure custom rules and guidelines to provide context-aware assistance in Auggie CLI.

## Overview

Auggie automatically loads custom rules and guidelines from several file locations to provide context-aware assistance. These files help Auggie understand your project's conventions, coding standards, and preferences.

<Note>The Auggie CLI uses the same rules system as the VSCode and JetBrains IDE extensions. For more information on IDE specific features like user guidelines, see [Rules & Guidelines for Agent and Chat](/setup-augment/guidelines).</Note>

## Supported Rules Files

Auggie looks for rules files in the following order of precedence:

1. **Custom rules file** (via `--rules` flag): `/path/to/custom-rules.md`
2. **CLAUDE.md**: Compatible with Claude Code and other AI tools
3. **AGENTS.md**: Compatible with Cursor and other AI development tools
4. **Workspace guidelines**: `<workspace_root>/.augment/guidelines.md` (legacy format)
5. **Workspace rules folder**: `<workspace_root>/.augment/rules/` - Recursively searches .md files in the workspace
6. **User rules folder**: `~/.augment/rules/` - Recursively searches .md files for user-wide rules

### User Rules vs Workspace Rules

Rules can be defined at two levels:

| Scope     | Location                           | Availability                        |
| :-------- | :--------------------------------- | :---------------------------------- |
| User      | `~/.augment/rules/`                | Available in all workspaces         |
| Workspace | `<workspace_root>/.augment/rules/` | Available in current workspace only |

**User rules** are stored in your home directory and apply to all projects. Use these for personal preferences, coding style guidelines, or conventions you want to follow across all your work. User rules are always treated as `always_apply` type and are automatically included in every prompt regardless of any frontmatter configuration.

**Workspace rules** are stored in the project repository and apply only to that specific project. Use these for project-specific guidelines that should be shared with your team via version control.

## Rules File Format

Rules files should be written in Markdown format with natural language instructions. Here's the recommended structure:

```markdown theme={null}
# Project Guidelines

## Code Style
- Use TypeScript for all new JavaScript files
- Follow the existing naming conventions in the codebase
- Add JSDoc comments for all public functions and classes

## Architecture
- Follow the MVC pattern established in the codebase
- Place business logic in service classes
- Keep controllers thin and focused on request/response handling

## Testing
- Write unit tests for all new functions
- Maintain test coverage above 80%
- Use Jest for testing framework

## Dependencies
- Prefer built-in Node.js modules when possible
- Use npm for package management
- Pin exact versions in package.json for production dependencies
```

## Frontmatter Configuration for Rules

Rules files in the `<workspace_root>/.augment/rules/` (workspace) directory support frontmatter to configure their behavior. Use YAML frontmatter at the beginning of your rule file to specify how the rule should be applied:

<Note>User rules in `~/.augment/rules/` are always treated as `always_apply` and do not support other frontmatter types. Frontmatter configuration only affects workspace rules.</Note>

| Frontmatter Field | Purpose                                                                       | Options                           | Default        |
| :---------------- | :---------------------------------------------------------------------------- | :-------------------------------- | :------------- |
| `type`            | Controls when the rule is applied                                             | `always_apply`, `agent_requested` | `always_apply` |
| `description`     | Brief description of the rule's purpose (required for `agent_requested` type) | Any text                          | None           |

**Rule Types:**

* **`always_apply`**: Rule contents are automatically included in every user prompt
* **`agent_requested`**: Rule is automatically detected and attached based on the description field when relevant

<Note>Manual rules are not yet supported in the CLI. In the CLI, workspace rules in `<workspace_root>/.augment/rules/` are currently treated as `always_apply` rules and automatically included. User rules in `~/.augment/rules/` are always `always_apply`. The `manual` type only works in the IDE extensions where you can use @ mentions to selectively attach rules.</Note>

Use `agent_requested` (also called `auto` in IDE extensions) over `always_apply` if you want to optimize context usage. For these rules, the agent will determine the rule is relevant to your current task, ensuring specialized guidelines are available when needed.

**Example with frontmatter:**

```markdown theme={null}
---
type: always_apply
---

# TypeScript Guidelines

- Use strict mode in all TypeScript files
- Define explicit return types for all functions
- Avoid using `any` type unless absolutely necessary
```

**Agent-requested example:**

```markdown theme={null}
---
type: agent_requested
description: React component development patterns and best practices
---

# React Component Guidelines

- Use functional components with hooks
- Implement proper TypeScript interfaces for props
- Follow the established folder structure in src/components/
```

## Hierarchical Rules

In addition to workspace-level rules, the agent supports **hierarchical rules** through `AGENTS.md` and `CLAUDE.md` files placed in subdirectories. When working on files in a subdirectory, Augment automatically discovers and applies rule files from that directory and all parent directories.

### How Hierarchical Rules Work

1. When you work on a file, Augment looks for `AGENTS.md` and `CLAUDE.md` in the file's directory
2. It then walks up the directory tree, checking each parent directory for these files
3. All discovered rules are included in the context for that work session
4. The search stops at the workspace root (since workspace root rules are already loaded separately)

### Example Directory Structure

```
my-project/
  AGENTS.md                  <- Always included (workspace root)
  src/
    AGENTS.md                <- Included when working in src/ or subdirectories
    frontend/
      AGENTS.md              <- Included when working in src/frontend/
      App.tsx
    backend/
      AGENTS.md              <- Included when working in src/backend/
      server.ts
  tests/
    AGENTS.md                <- Only included when working in tests/
```

When working on `src/frontend/App.tsx`:

* `src/frontend/AGENTS.md` is loaded (current directory)
* `src/AGENTS.md` is loaded (parent directory)
* `AGENTS.md` at workspace root is loaded via standard rules
* `src/backend/AGENTS.md` and `tests/AGENTS.md` are **not** loaded (different branches)

### Use Cases for Hierarchical Rules

* **Framework-specific guidelines**: Place React-specific rules in your frontend directory and Node.js rules in your backend directory
* **Module-specific conventions**: Define API design patterns in your `api/` directory
* **Test-specific rules**: Add testing conventions that only apply when writing tests
* **Team boundaries**: Different teams can maintain their own coding standards in their directories

### Important Notes

* Only `AGENTS.md` and `CLAUDE.md` files are discovered hierarchically
* Files in `.augment/rules/` are only loaded from the workspace root, not from subdirectories
* Rules are cached per conversation session to avoid duplicate inclusion
* Hierarchical rules are combined with workspace and user rules

## Best Practices for Rules Files

1. **Be Specific**: Provide clear, actionable guidelines rather than vague suggestions
2. **Use Examples**: Include code examples when describing patterns or conventions
3. **Keep Updated**: Regularly review and update rules as your project evolves
4. **Be Concise**: Focus on the most important guidelines to avoid overwhelming the AI
5. **Test Guidelines**: Verify that Auggie follows your rules by testing with sample requests

## Command-Line Flag

You can specify a custom rules file when starting Auggie:

```bash theme={null}
auggie --rules /path/to/custom-rules.md
```

This will append the specified rules to any workspace guidelines that are automatically loaded.

## See Also

* [Rules & Guidelines for Agent and Chat](/setup-augment/guidelines) - Configure rules in VSCode and JetBrains IDEs
* [CLI Reference](/cli/reference) - Complete command-line reference
* [Workspace Context](/cli/setup-auggie/workspace-context) - Understanding workspace configuration
* [Custom Commands](/cli/custom-commands) - Create reusable command templates


# Auggie SDK
Source: https://docs.augmentcode.com/cli/sdk

Build custom integrations and agents using the Auggie SDK.

<CardGroup>
  <Card title="TypeScript SDK" icon="js" href="/cli/sdk-typescript">
    Build Node.js and TypeScript applications with the Auggie SDK
  </Card>

  <Card title="Python SDK" icon="python" href="/cli/sdk-python">
    Build Python applications with the Auggie SDK
  </Card>
</CardGroup>

## Installation

<CodeGroup>
  ```sh TypeScript theme={null}
  npm install @augmentcode/auggie-sdk
  ```

  ```sh Python theme={null}
  pip install auggie-sdk
  ```
</CodeGroup>

## Authentication

The Auggie SDK supports multiple authentication methods:

1. **Passing API Key Directly (Recommended)** - Provide `apiKey` parameter when initializing
2. **Using Environment Variables** - Set `AUGMENT_API_TOKEN` and `AUGMENT_API_URL` environment variables
3. **Using `settings.json`** - Store credentials in `settings.json` file

### Finding Your API keys

<Note>
  **Coming Soon:** Service accounts and team-level tokens will be available for production deployments and CI/CD environments.
</Note>

Running `auggie token print` will print your API keys:

```json theme={null}
{
  "accessToken": "ABC-XYZ-123", // Use as apiKey
  "tenantURL": "https://...",   // Use as apiUrl
  ...
}
```

## Quick Start

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { Auggie } from "@augmentcode/auggie-sdk";

  const client = await Auggie.create({ model: "sonnet4.5" });
  const response = await client.prompt("What files are in the current directory?");
  console.log(response);
  await client.close();
  ```

  ```python Python theme={null}
  from auggie_sdk import Auggie

  agent = Auggie(model="sonnet4.5")
  result = agent.run("What is 2 + 2?", return_type=int)
  print(result)  # 4
  ```
</CodeGroup>

## Key Features

Both SDKs provide:

* **High-level API** - Simple interface for common tasks
* **Multiple Output Modes** - String responses, typed returns, streaming, and more
* **Codebase Awareness** - Automatic indexing and context from your workspace
* **Custom Tools** - Extend Auggie with your own tools and integrations


# Python SDK
Source: https://docs.augmentcode.com/cli/sdk-python

Build custom integrations and agents using the Auggie Python SDK.

## About

The Auggie Python SDK provides a programmatic interface to Auggie for building custom integrations and agents in Python applications.

## Installation

```sh theme={null}
pip install auggie-sdk
```

## Usage

### Basic Initialization

```python theme={null}
from auggie_sdk import Auggie

# Simple initialization
agent = Auggie(model="sonnet4.5")

# Run a task
result = agent.run("What is 2 + 2?", return_type=int)
print(result)  # 4
```

### Full Configuration

```python theme={null}
from auggie_sdk import Auggie
from auggie_sdk.acp import AgentEventListener

# Optional: Create a custom event listener
class MyListener(AgentEventListener):
    def on_agent_message_chunk(self, text: str):
        print(text, end="", flush=True)

agent = Auggie(
    # Working directory for the agent (default: current directory)
    workspace_root="/path/to/workspace",

    # Model to use: "haiku4.5" | "sonnet4.5" | "sonnet4" | "gpt5"
    model="sonnet4.5",

    # Event listener for real-time updates (optional)
    listener=MyListener(),

    # Allow codebase indexing (default: True)
    allow_indexing=True,

    # Default timeout in seconds (default: 300)
    timeout=600,

    # API key for authentication (optional, sets AUGMENT_API_TOKEN)
    api_key="your-api-key",

    # API URL (optional, sets AUGMENT_API_URL)
    api_url="https://api.augmentcode.com",

    # Rule file paths (optional)
    rules=["/path/to/rules.md"],

    # Additional CLI arguments (optional)
    cli_args=["--quiet", "--max-turns", "10"]
)

# Use the agent
result = agent.run("Your question here", return_type=str)
print(result)
```

### Custom CLI Arguments

The `cli_args` parameter allows you to pass additional command-line arguments to the Auggie CLI when spawning the agent process. This is useful for passing custom or experimental CLI flags that aren't exposed as dedicated parameters.

```python theme={null}
from auggie_sdk import Auggie

# Example 1: Limit agent turns and reduce output
agent = Auggie(
    cli_args=["--quiet", "--max-turns", "10"]
)

# Example 2: Configure retry behavior and shell
agent = Auggie(
    cli_args=["--retry-timeout", "60", "--shell", "bash"]
)

# Example 3: Add custom rules and startup script
agent = Auggie(
    cli_args=[
        "--rules", "/path/to/custom-rules.md",
        "--startup-script", "export MY_VAR=value"
    ]
)

# Example 4: Configure tool permissions
agent = Auggie(
    cli_args=[
        "--permission", "web-search:allow",
        "--permission", "launch-process:ask-user"
    ]
)
```

**Common CLI arguments:**

* `--quiet` - Only show final assistant message
* `--max-turns <n>` - Limit the number of agentic turns
* `--retry-timeout <sec>` - Timeout for rate-limit retries (seconds)
* `--shell <name>` - Select shell: bash | zsh | fish | powershell
* `--rules <path>` - Additional rules file (repeatable)
* `--permission <rule>` - Set tool permissions with 'tool-name:policy' format
* `--startup-script <script>` - Inline startup script to run before each command

The `cli_args` are appended after all other CLI arguments, giving you flexibility to pass any additional flags or options supported by the underlying Auggie CLI. See the [CLI reference](/cli/reference) for available command-line options.

## Output Modes

The Python SDK supports multiple output modes to fit different use cases:

### Typed Returns

Specify the exact type you expect, and the SDK ensures the agent returns data in that format:

```python theme={null}
from auggie_sdk import Auggie

agent = Auggie()

# Get an integer
result = agent.run("What is 15 + 27?", return_type=int)
print(result)  # 42

# Get a dictionary
weather = agent.run(
    "Get weather info for Tokyo",
    return_type=dict
)

# Get a list
files = agent.run(
    "List all Python files",
    return_type=list
)
```

### Automatic Type Inference

When no `return_type` is specified, the agent automatically infers the best type:

```python theme={null}
result, inferred_type = agent.run("What is 15 + 27?")
print(f"Result: {result} (type: {inferred_type.__name__})")
# Result: 42 (type: int)
```

### Structured Data with Dataclasses

Return complex structured data using Python dataclasses:

```python theme={null}
from dataclasses import dataclass
from typing import List

@dataclass
class Task:
    id: int
    description: str
    is_done: bool

# Get a single object
task = agent.run(
    "Create a sample task for 'Buy groceries'",
    return_type=Task
)

# Get a list of objects
tasks = agent.run(
    "Create 3 sample tasks for a weekend to-do list",
    return_type=List[Task]
)
```

### Streaming Mode

Listen to real-time updates using an event listener:

```python theme={null}
from auggie_sdk import Auggie
from auggie_sdk.acp import AgentEventListener

class MyListener(AgentEventListener):
    def on_agent_message_chunk(self, text: str):
        """Called when agent sends response chunks (streaming)."""
        print(text, end="", flush=True)

    def on_tool_call(self, tool_call_id, title, kind=None, status=None):
        """Called when agent makes a tool call."""
        print(f"\n🔧 Using tool: {title}")

agent = Auggie(listener=MyListener())
result = agent.run("Your question here")
```

**Supported return types:** `int`, `float`, `str`, `bool`, `list`, `dict`, `List[T]`, `Dict[K, V]`, `dataclasses`, `Enum`

## Custom Functions

The Python SDK supports **custom function calling**, allowing you to provide Python functions that the agent can intelligently call during execution. This enables the agent to interact with external systems, perform calculations, fetch data, and more.

### Creating Custom Functions

Define Python functions with type hints and docstrings. The agent will automatically understand how to use them:

```python theme={null}
from auggie_sdk import Auggie
import datetime


def get_current_weather(location: str, unit: str = "celsius") -> dict:
    """
    Gets the weather for a given location.

    Args:
        location: The city and state, e.g. San Francisco, CA
        unit: Temperature unit ('celsius' or 'fahrenheit')
    """
    # In a real app, you'd call a weather API here
    return {"temp": 72, "unit": unit, "forecast": "sunny"}


def get_time() -> str:
    """Returns the current time."""
    return datetime.datetime.now().strftime("%H:%M")


agent = Auggie()

# The agent will call the appropriate function(s) to answer the question
response = agent.run(
    "What's the weather like in NYC right now, and what time is it there?",
    functions=[get_current_weather, get_time],
)
print(response)
```

### Function Requirements

For functions to work properly with the agent:

1. **Type Hints Required**: All parameters must have type annotations
2. **Docstrings Required**: Function must have a docstring with:
   * Function description (first paragraph)
   * Parameter descriptions in the `Args:` section
3. **JSON-Serializable**: Arguments and return values must be JSON-serializable
4. **Keyword Arguments**: Functions must accept keyword arguments

### Example with Multiple Functions

```python theme={null}
from auggie_sdk import Auggie


def add_numbers(a: int, b: int) -> int:
    """Add two numbers together.

    Args:
        a: First number
        b: Second number
    """
    return a + b


def multiply_numbers(a: int, b: int) -> int:
    """Multiply two numbers together.

    Args:
        a: First number
        b: Second number
    """
    return a * b


agent = Auggie()

result = agent.run(
    "What is (15 + 27) multiplied by 3?",
    return_type=int,
    functions=[add_numbers, multiply_numbers],
)
print(result)  # 126
```

### How It Works

1. Function schemas are automatically generated from type hints and docstrings
2. The agent receives the instruction and available functions
3. The agent intelligently decides when to call functions
4. The SDK executes the functions and sends results back to the agent
5. The agent continues processing and can call more functions if needed
6. Final response is returned according to `return_type`

<Note>
  **Function Calling Limits**: Function calling is limited to 5 rounds to prevent infinite loops.
</Note>

## See Also

* [Python SDK on PyPI](https://pypi.org/project/auggie-sdk)
* [TypeScript SDK](/cli/sdk-typescript)
* [ACP Clients](/cli/acp/clients)


# TypeScript SDK
Source: https://docs.augmentcode.com/cli/sdk-typescript

Build custom integrations and agents using the Auggie TypeScript SDK.

## About

The Auggie TypeScript SDK provides a programmatic interface to Auggie for building custom integrations and agents in Node.js and TypeScript applications.

## Installation

```sh theme={null}
npm install @augmentcode/auggie-sdk
```

## Usage

### Basic Initialization

```typescript theme={null}
import { Auggie } from "@augmentcode/auggie-sdk";

// Simple initialization
const client = await Auggie.create({
  model: "sonnet4.5"
});

// Send a prompt
const response = await client.prompt("What files are in the current directory?");
console.log(response);

// Close the connection
await client.close();
```

### Full Configuration

```typescript theme={null}
import { Auggie } from "@augmentcode/auggie-sdk";

const client = await Auggie.create({
  // Path to Auggie executable (default: "auggie")
  auggiePath: "/path/to/auggie",

  // Working directory for the Auggie process (default: process.cwd())
  workspaceRoot: "/path/to/workspace",

  // Eg: "haiku4.5" | "gpt-5" | "sonnet4.5" | "sonnet4"
  model: "sonnet4.5",

  // Allow codebase indexing (default: true)
  allowIndexing: true,

  // API key for authentication (optional, sets AUGMENT_API_TOKEN)
  apiKey: "your-api-key",

  // API URL (optional, sets AUGMENT_API_URL)
  apiUrl: "https://api.augmentcode.com",

  // Custom tools to provide to Auggie (optional)
  tools: {
    // Your custom tools here
  },

  // Rule file paths (optional)
  rules: ["/path/to/rules.md"],

  // Additional CLI arguments to pass to the Auggie process (optional)
  cliArgs: ["--quiet", "--max-turns=10"]
});

// Use the client
const response = await client.prompt("Your question here");
console.log(response);

await client.close();
```

### Advanced CLI Arguments

The `cliArgs` option allows you to pass additional command-line arguments directly to the Auggie CLI process. These arguments are appended after all SDK-generated flags, allowing you to use advanced configurations or experimental flags not exposed through standard SDK options.

```typescript theme={null}
import { Auggie } from "@augmentcode/auggie-sdk";

// Pass custom CLI flags
const client = await Auggie.create({
  model: "sonnet4.5",
  cliArgs: ["--quiet", "--max-turns=10"]
});

// Arguments can use either format:
// 1. Separate flag and value: ["--retry-timeout", "60"]
// 2. Combined with equals: ["--retry-timeout=60"]
const client2 = await Auggie.create({
  model: "sonnet4.5",
  cliArgs: ["--shell=bash", "--allow-indexing"]
});
```

**Note:** Since `cliArgs` are appended after SDK-generated flags, they can override default values when the CLI uses a last-value-wins strategy. Refer to `auggie --help` for available CLI flags.

## Output Modes

The TypeScript SDK supports multiple output modes to fit different use cases:

### String Response (Default)

By default, the SDK returns the complete agent response as a string:

```typescript theme={null}
const client = await Auggie.create({ model: "sonnet4.5" });
const response = await client.prompt("What files are in the current directory?");
console.log(response); // Full response as string
```

### Answer-Only Mode

Get only the final answer after all tool calls complete, excluding intermediate reasoning:

```typescript theme={null}
const finalAnswer = await client.prompt(
  "List all TypeScript files in this project",
  { isAnswerOnly: true }
);
// Returns only the final response after tool execution
```

### Streaming Mode

Listen to real-time updates as the agent processes your request:

```typescript theme={null}
client.onSessionUpdate((event) => {
  switch (event.update.sessionUpdate) {
    case "agent_message_chunk":
      if (event.update.content.type === "text") {
        process.stdout.write(event.update.content.text);
      }
      break;
    case "tool_call":
      console.log(`\nTool: ${event.update.title}`);
      break;
    case "tool_call_update":
      console.log("Output:", event.update.rawOutput);
      break;
  }
});

const response = await client.prompt("Your question here");
```

## Custom Tools

The TypeScript SDK supports **ai-sdk compatible tools**, allowing you to extend Auggie with custom functionality. You can provide tools that the agent can call during execution.

### Creating a Custom Tool

Here's an example of a custom weather tool:

```typescript theme={null}
import { Auggie } from "@augmentcode/auggie-sdk";
import { tool } from "ai";
import { z } from "zod";

// Define a custom tool
const weather_tool = tool({
  name: "get_weather",
  description: "Get the weather in a location",
  inputSchema: z.object({
    location: z.string().describe("The location to get the weather for"),
  }),
  execute: ({ location }) => {
    console.log(`\n Weather tool called for location: ${location}`);
    return `The weather in ${location} is sunny.`;
  },
});

// Initialize Auggie with the custom tool
const client = await Auggie.create({
  model: "sonnet4.5",
  tools: {
    get_weather: weather_tool,
  },
});

// The agent can now use the weather tool
const response = await client.prompt("What's the weather like in San Francisco?");
console.log(response);

await client.close();
```

### Key Points

* **ai-sdk Compatible**: Tools follow the [Vercel AI SDK](https://sdk.vercel.ai/docs) tool format
* **Zod Schemas**: Use Zod for input validation and type safety
* **Automatic Discovery**: The agent automatically discovers and uses available tools when relevant
* **Multiple Tools**: Pass multiple tools in the `tools` object

### Tool Structure

Each tool requires:

* `name` - Unique identifier for the tool
* `description` - Clear description of what the tool does (helps the agent decide when to use it)
* `inputSchema` - Zod schema defining the tool's input parameters
* `execute` - Function that implements the tool's logic


# Login and authentication
Source: https://docs.augmentcode.com/cli/setup-auggie/authentication

You will need an active account and valid session token to use Auggie CLI which you can get by following the instructions below.

## About authentication

Before you can use Auggie, you will need to login to create a session token that can be used by Auggie in both interactive and automation modes.

<Note>Augment authentication tokens are secrets and should be protected with the same level of security you'd use for any sensitive credential. Tokens are tied to the user who logged in, not to your team or enterprise account, so each user has a unique augment token.</Note>

## Logging in

You can login by running the following command and following the prompts.

```sh theme={null}
auggie login
```

## Logging out

You can logout by running the following command. This will remove the local token from your machine and you will need to login again to use Auggie.

```sh theme={null}
auggie logout
```

## Getting your token

For automation, you will need to provide your token each time you run Auggie. After you have logged in above, you can get your token by running the following command.

```sh theme={null}
auggie tokens print
```

## Using your token

After you have your token, you can pass it to Auggie through a number of methods depending on your use case and environment.

### Environment variables

You can set the `AUGMENT_SESSION_AUTH` environment variable to your token before running Auggie. Pass it before you run the command, add it to your environment, or add it to your shell's rc file to persist it.

```sh theme={null}
AUGMENT_SESSION_AUTH='<token>'
```

### Token file

You can store the token as plaintext in a file and then use the `--augment-token-file` flag to pass it to Auggie. We do not recommend checking your token into version control.

```sh theme={null}
auggie --augment-token-file /path/to/token
```

## Revoking your tokens

You can expire all the tokens for the current logged in user by running the following command. Using `--logout` will only remove the local token from your machine.

```sh theme={null}
auggie tokens revoke 
```


# Install Auggie CLI
Source: https://docs.augmentcode.com/cli/setup-auggie/install-auggie-cli

Install Auggie to get agentic coding capabilities in your terminal, on your server, or anywhere your code runs.

```sh theme={null}
npm install -g @augmentcode/auggie
```

# About installing Auggie

Installing Auggie CLI is easy and will take you less than a minute. You can install Auggie CLI directly from npm anywhere you can run Node 22 or later. Many systems do not ship with the latest version of Node.js, so you may need to upgrade Node to use Auggie.

Auggie is currently in beta and may not run on all environments and terminal configurations.

## Automatic Updates

Auggie CLI automatically updates itself when running in interactive mode to ensure you always have the latest features and bug fixes. This feature is enabled by default and works seamlessly in the background. You can [disable automatic updates](/cli/reference#environment-variables).

## System requirements

* [**Node.js 22+**](https://nodejs.org/en/download/)
* **Platforms**: MacOS, Windows WSL, Linux
* **Shells**: zsh, bash, fish

### Interactive mode

Using Auggie in interactive mode requires a terminal that supports ANSI escape codes. We recommend using Ghostty, iTerm2, MacOS Terminal, Windows Terminal, Alacritty, Kitty, and other modern terminals.

If you are connecting to your shell over SSH or through tmux you may need to adjust your terminal settings or configuration to enable proper color support, font rendering, and interactivity.


# Workspace context
Source: https://docs.augmentcode.com/cli/setup-auggie/workspace-context

Auggie will automatically index the current working directory or directory you specify to give Augment a full view of your system.

## About Workspace Context

Augment is powered by its deep understanding of your code. Your codebase will be automatically indexed when you run `auggie` from a git directory or you can specify a directory to index. If you run Auggie from a non-git directory, a temporary workspace will be created for you.

## Specifying a directory to index

To specify a directory other than the current working directory pass the target directory to the `--workspace-root` flag.

```sh theme={null}
auggie --workspace-root /path/to/your/project
```

To learn more about what files are indexed and how to ignore files, see [Workspace indexing](/cli/setup-auggie/workspace-indexing).


# Index your workspace
Source: https://docs.augmentcode.com/cli/setup-auggie/workspace-indexing

When your workspace is indexed, Augment can provide tailored code suggestions and answers based on your unique codebase, best practices, coding patterns, and preferences. You can always control what files are indexed.

## Security and privacy

Augment stores your code securely and privately to enable our powerful context engine. We ensure code privacy through a proof-of-possession API and maintain strict internal data minimization principles. [Read more about our security](https://www.augmentcode.com/security).

## What gets indexed

Augment will index all the files in your workspace, except for the files that match patterns in your `.gitignore` file and the `.augmentignore` file. [Read more about Workspace Context](/cli/setup-auggie/workspace-context).

## Ignoring files with .augmentignore

The `.augmentignore` file is a list of file patterns that Augment will ignore when indexing your workspace. Create an `.augmentignore` file in the root of your workspace. You can use any glob pattern that is supported by the [gitignore](https://git-scm.com/docs/gitignore) file.

## Including files that are .gitignored

If you have a file or directory in your `.gitignore` that you want to be indexed, you can add it to your `.augmentignore` file using the `!` prefix.

For example, you may want your `node_modules` indexed to provide Augment with context about the dependencies in their project, but it is typically included in their `.gitignore`. Add `!node_modules` to your `.augmentignore` file.

<CodeGroup>
  ```bash .augmentignore theme={null}
  # Include .gitignore excluded files with ! prefix
  !node_modules

  # Exclude other files with .gitignore syntax
  data/test.json
  ```

  ```bash .gitignore theme={null}
  # Exclude dependencies
  node_modules

  # Exclude secrets
  .env

  # Exclude build artifacts
  out
  build
  ```
</CodeGroup>


# Subagents
Source: https://docs.augmentcode.com/cli/subagents

Configure custom agents for specific tasks to automate your workflow and share them with your team.

<Availability />

## About subagents

Subagents are custom agents that you can configure for specialized tasks, like code review or project bootstrapping. Each subagent has its own tools and capabilities that you can delegate specific tasks to. You can have local subagents or share them with your team by adding their configuration to your repository.

* Subagents have their own context window independent from the main agent
* Subagents have a custom prompt that is used to instruct the agent
* Subagents run in parallel with other subagents
* Subagents will show a summary of their current progress in the main thread

## Create a subagent

You can create a new subagent through the wizard by running `/agents` command in interactive mode. Or you can create the configuration file manually.

### Create a subagent with the wizard

1. Run the `/agents` command in interactive mode
2. Select "Create new agent"
3. Select where you want the agent configuration to be stored
4. Complete the following fields to configure the agent:
   * Name
   * Description
   * Color
   * Model
   * Prompt
5. Review the configuration and press enter to save the agent

### Create a subagent manually

You can create a subagent manually by creating a configuration file. The configuration file should be a markdown file stored in either `~/.augment/agents/` (user only) or `./.augment/agents/` (shared). See the [Subagent configuration reference](#subagent-configuration-reference) for more details.

**Example subagent configuration:**

```markdown theme={null}
---
name: code-review
description: Code review agent
model: sonnet4.5
color: purple
---

You are an agentic code-review AI assistant with access to the developer's codebase through Augment's deep codebase context engine and integrations. You are conducting a comprehensive code review for the staged changes in the current working directory.

## Review Areas to focus on:

- **Potential Bugs**: Identify bugs, logic errors, edge cases, crash-causing problems.
- **Security Concerns**: Look for potential vulnerabilities, input validation, authentication issues ONLY if the code is security-sensitive
- **Documentation**: Report comments or documentation that is incorrect or inconsistent with the code.
- **API contract violations**
- **Database and schema errors**
- **High Value Typos**: typos that affect correctness, UX-strings, etc.
```

## Running your subagent

Once you've configured the subagent, you can trigger it by sending a message that references the agent name. Augment will also automatically detect when a task is appropriate for a subagent and offer to use it.

```
> Use the code-review agent to review my staged changes
```

## Subagent configuration reference

### File locations

Subagents are configured in markdown files with YAML frontmatter. Subagents can be configured at the user level or the workspace level. User-level subagents are available in all workspaces, while workspace-level subagents are only available in the current workspace.

| Scope     | Location             | Availability                        |
| :-------- | :------------------- | :---------------------------------- |
| User      | `~/.augment/agents/` | Available in all workspaces         |
| Workspace | `./.augment/agents/` | Available in current workspace only |

### Frontmatter configuration

| Field         | Required | Purpose                                                                      |
| :------------ | :------- | :--------------------------------------------------------------------------- |
| **`name`**    | **Yes**  | **Name of the agent**                                                        |
| `description` | No       | Description of the agent                                                     |
| `color`       | No       | Color of the agent in the CLI, should be a valid ANSI color name.            |
| `model`       | No       | Model to use for the agent. If not specified, the CLI default model is used. |

### Supported models

Subagents can use any model available in Auggie. To see a list of available models, run the following command:

```bash theme={null}
auggie models list
```

This will display all supported models along with their identifiers that you can use in your subagent configuration.

<Note>
  Model availability may vary depending on your Augment subscription and organization settings.
</Note>

### Agent prompt

The agent prompt is the main body of the markdown file. The prompt is used to instruct the agent on its role and capabilities. The prompt can include any information that you want to be available to the agent, including specific tools or instructions. The prompt is rendered as markdown and supports code blocks, lists, and other formatting.

## Best practices for subagents

* **Subagents are most effective when they have a specific and focused task.** It is better to create multiple subagents for different tasks rather than trying to create a single agent for multi-step, long-running, or complex tasks.
* **Subagents should have a detailed prompt**. The prompt should clearly define the agent's role, capabilities, and expected behavior. Include specific instructions, task lists, examples, and expected output. Take advantage of markdown formatting to make the prompt as clear as possible.
* **Share your subagents with your team**. Subagents are a great way to share custom workflows with your team. Store your subagents in your projects `./.augment/agents/` directory to make them available to everyone.

## Example subagents

### Code review agent

```markdown theme={null}
---
name: code-review
description: Code review agent
model: sonnet4.5
color: purple
---

You are an agentic code-review AI assistant with access to the developer's codebase through Augment's deep codebase context engine and integrations. You are conducting a comprehensive code review for the staged changes in the current working directory.

Review Areas to focus on:

- **Potential Bugs**: Identify bugs, logic errors, edge cases, crash-causing problems.
- **Security Concerns**: Look for potential vulnerabilities, input validation, authentication issues ONLY if the code is security-sensitive
- **Documentation**: Report comments or documentation that is incorrect or inconsistent with the code.
- **API contract violations**
- **Database and schema errors**
- **High Value Typos**: typos that affect correctness, UX-strings, etc.

Review Areas to avoid:

- **Style nags**: e.g. prefer `const` over `let`, prefer template strings, etc.
- **Opinionated suggestions**: e.g. prefer `map` over `forEach`, etc.
- **Low value typos**: e.g. spelling errors in comments, etc.
```

### Test generation agent

```markdown theme={null}
---
name: test-generation
description: Generates and runs tests for new or modified code
model: sonnet4.5
color: green
---

You are an agentic test generation AI assistant. You are responsible for writing thorough and high quality automated tests for this software project. You have access to the codebase through Augment's deep codebase context engine and integrations, and are able to run commands through the terminal.

Your goals:

1. Analyze recent code changes or diffs to identify new or modified functions, classes, or modules.
2. Determine which parts of the changes are missing test coverage.
3. Generate clear, idiomatic unit or integration tests using the project's existing testing framework and conventions.
4. Write test files or append tests to existing files in appropriate locations.
5. Run the test suite and summarize results, including:
   - Number of tests added or updated
   - Any failures or skipped tests
   - Edge cases or scenarios still untested
6. If a test fails immediately, analyze the likely cause and propose fixes or clarifications.

Guidelines:

- Favor readability, determinism, and minimal mocking.
- Reuse existing helper utilities and fixtures if present.
- Match the naming conventions and import patterns found in the repository.
- Always include at least one negative test (an example where the function should fail).

```

### API designer agent

```markdown theme={null}
---
name: api-designer
description: Use for designing REST/GraphQL APIs, OpenAPI specs, and API documentation
model: sonnet4.5
color: blue
---

You are an API design specialist focused on creating well-structured, intuitive, and maintainable APIs. You are responsible for designing and documenting APIs for this software project. You have access to the codebase through Augment's deep codebase context engine and integrations, and are able to run commands through the terminal.

## Design Principles

- Use consistent naming conventions (plural nouns for resources)
- Implement proper HTTP methods and status codes
- Design for idempotency where appropriate
- Include pagination for list endpoints
- Provide filtering, sorting, and field selection
- Follow HATEOAS principles for discoverability
- Implement rate limiting considerations

## API Patterns

**REST Best Practices:**

- `/api/v1/resources` - Collection endpoint
- `/api/v1/resources/{id}` - Single resource
- `/api/v1/resources/{id}/relationships` - Nested resources
- Use query params for filtering: `?status=active&sort=-created_at`

**Error Responses:**

- Return consistent error format with code, message, details
- Use appropriate HTTP status codes (400, 401, 404, 422, 500)

## Documentation Style

- Generate or update OpenAPI 3.0+ spec
- Include examples for all endpoints

```


# Analytics Dashboard
Source: https://docs.augmentcode.com/codereview/analytics-dashboard

Track code review metrics and measure the impact of Augment Code Review on your team.

## Code Review Analytics

Use the Code Review Analytics dashboard to track the review load automated by Augment, along with the comments made by Code Review that developers ultimately addressed.

1. **Navigate to Code Review** - In your browser, visit [Code Review Analytics](https://app.augmentcode.com/code-review/analytics).
2. **Filter by Date** - Refine your Analytics using the tabs for Last 7 Days, Last 30 Days, or Last 60 Days.

### Metric Definitions

* **Total PRs Reviewed**: The number of PRs that have been reviewed by Augment Code Review.
* **Total Reviews Performed**: The number of reviews that have been run by Augment Code Review. One PR can have multiple reviews if people manually trigger more reviews.
* **Total Comments**: The total number of inline comments left by Augment Code Review.
* **Percentage of Comments Addressed**: A comment is addressed if the developer resolved the concerns raised by the Augment Code Review comment. The percentage is calculated by dividing the number of addressed comments by the total number of comments left by Augment Code Review.
* **Percentage of Thumbs Up Reactions**: A thumbs up reaction is counted if a user reacts with the Thumbs Up emoji on GitHub on an inline comment left by Augment Code Review. The percentage is calculated by dividing the number of thumbs up reactions by the total number of thumbs up and thumbs down emoji reactions.
* **Estimated Dev Hours Saved**: Number of PRs multiplied by 10 minutes

### Reading the Charts

* **Addressed Comments**: A chart detailing total number of comments per day broken down by unaddressed (gray) vs addressed (green). You can interpret the green bar to mean Augment Code Review caught issues that developers fixed and may not have without the comment.
* **Reviewed PRs**: A chart detailing the total number of reviewed PRs per day (blue).


# Auto-Generated PR Descriptions
Source: https://docs.augmentcode.com/codereview/auto-generated-pr-descriptions

Generates comprehensive PR descriptions using Augment Code's Context Engine.

After Augment Code Review has reviewed your pull request, it will leave a comment summarizing the work to that point. This description saves reviewers time by handling the 'what' and 'how' of the changes, allowing them to focus on explaining the 'why' and the broader context. The result: faster reviews, better collaboration, and more time on building.

## How It Works

1. **Create Your PR**: Open a pull request in GitHub with your code changes
2. **Automatic Analysis**: Augment's Context Engine analyzes your code diff and understands the changes in the context of your entire codebase
3. **Description Generation**: A comprehensive PR description is automatically generated, covering what changed, how it works, and potential impacts
4. **Review and Edit**: Review the generated description and add any additional context about why the changes were made
5. **Faster Reviews**: Reviewers can quickly understand your changes and provide meaningful feedback

## Best Practices

**Review Before Accepting**: Always review the auto-generated description to ensure accuracy and completeness. The AI understands your code, but you understand the business context.

**Add the 'Why'**: Supplement the generated description with the reasoning behind your changes. This helps reviewers understand not just what changed, but why it matters.

**Keep PRs Focused**: Smaller, focused PRs result in more accurate and useful descriptions. Avoid mixing unrelated changes in a single PR.

**Update for Significant Changes**: If you make substantial changes to your PR after the description is generated, consider regenerating or manually updating the description.

**Use as a Starting Point**: Treat the auto-generated description as a foundation. Enhance it with project-specific context, design decisions, and any nuances the AI might miss.

**Give Reviewers Context**: Give reviewers comprehensive context upfront, leading to faster and more thorough reviews. At the same time, help new team members understand changes more quickly with detailed, consistent PR descriptions.


# Code Review Enterprise Features
Source: https://docs.augmentcode.com/codereview/enterprise-features

Advanced features and capabilities available to Enterprise plan customers for Augment Code Review.

## Overview

Augment Code Review Enterprise provides advanced features designed for organizations that need greater control, deeper integrations, and comprehensive analytics. This page outlines the key differences between self-serve and Enterprise plans.

## Feature Comparison

| Feature                | Self-Serve                 | Enterprise                                                         |
| ---------------------- | -------------------------- | ------------------------------------------------------------------ |
| **Advanced Analytics** | Total reviews performed    | Full dashboard with reviews, comments addressed, and team insights |
| **User Allowlist**     | All repo users get reviews | Control exactly which users receive PR reviews                     |
| **MCP Integration**    | Not available              | Connect to Jira, Linear, Notion, feature flags, and more           |
| **Multi-Org Support**  | Single GitHub organization | Multiple GitHub organizations per tenant                           |
| **Seats**              | Up to 20 seats             | Unlimited seats                                                    |
| **Connected Repos**    | Limited                    | Unlimited repositories                                             |

## Available Enterprise Features

### Advanced Analytics

Enterprise customers have access to a comprehensive analytics dashboard that goes beyond basic metrics:

* **Reviews Performed**: Track the total number of reviews completed by Augment Code Review
* **Comments Addressed**: See how many review comments were acted upon by developers
* **Engagement Metrics**: Understand how your team interacts with Code Review feedback

Self-serve users see only the total number of reviews performed.

<Note>
  Access the analytics dashboard at [Code Review Analytics](https://app.augmentcode.com/code-review/analytics).
</Note>

### User Allowlist

Enterprise administrators can specify exactly which GitHub users can trigger Augment Code Review. This provides fine-grained control over feature access within your organization.

When Allowlist Mode is active:

* Only users in the allowlist can trigger Augment Code Review
* Automatic and manual reviews are disabled for all other users
* Useful for phased rollouts or restricting access to specific teams

<Note>
  Manage your allowlist at [User Access Settings](https://app.augmentcode.com/settings/code-review/user-access).
</Note>

### MCP Integration

Connect Augment Code Review to your existing tools through Model Context Protocol (MCP). This enables the code review agent to gather additional context from your organization's systems:

* **Ticketing Systems**: Jira, Linear, and other issue trackers
* **Documentation**: Notion, Confluence, and internal wikis
* **Feature Flags**: LaunchDarkly, Split, and other feature management tools
* **Other Systems**: Any MCP-compatible tool relevant to your development workflow

This additional context allows Code Review to provide more informed and relevant feedback based on your team's specific requirements and documentation.

<Note>
  Configure MCP servers at [MCP Settings](https://app.augmentcode.com/settings/code-review/mcp).
</Note>

### Multi-Organization Support

Enterprise customers can install the Augment Code Review GitHub bot across multiple GitHub organizations or accounts. This is essential for:

* Organizations with separate GitHub orgs for different products or teams
* Companies that have acquired other organizations with existing GitHub structures
* Enterprises with strict organizational boundaries between business units

All organizations connect to a single Augment Enterprise tenant for unified management and billing.

### Unlimited Seats

Enterprise plans provide access to Augment Code Review for your entire organization without seat limitations. Self-serve plans are limited to 20 seats.

### Unlimited Connected Repositories

Enterprise customers can enable Code Review on an unlimited number of repositories. Self-serve plans have a cap on the number of repositories that can be connected.

## Getting Started with Enterprise

To upgrade to Enterprise or learn more about Enterprise features, visit [augmentcode.com/pricing](https://augmentcode.com/pricing) or contact our sales team.

If you're already an Enterprise customer, visit your [Code Review Settings](https://app.augmentcode.com/settings/code-review) to configure these features.


# Fix in Augment
Source: https://docs.augmentcode.com/codereview/fix-with-augment

Automatically address issues found during code review directly using the agent in your IDE or paste the details into your preferred environment to address it yourself.

When Augment Code Review identifies issues in your pull request, you can use the "Fix in Augment" button inside the comment to automatically address the issue.

<img alt="Fix in Augment button" />

Options include:

* **Open in Agent Session**: For VS Code only, allows you to copy the prompt and start a new thread inside the Augment Code extension
* **Copy to Clipboard**: Allows you to paste the prompt into your preferred environment, e.g. Auggie CLI, Augment Code for JetBrains, etc.

<img alt="Fix in Augment options" />

***

## Best Practices

**Review the Fix**: Always review the changes proposed by Agent before accepting them. While Agent has full context, you should verify the fix aligns with your intent.

**Test the Changes**: Run your tests after applying the fix to ensure the issue is resolved and no new issues are introduced.

**Update the PR**: After pushing your fix, you can reply to the Code Review comment to indicate you've addressed the issue.

**Request Follow-up Review**: If you make significant changes, consider requesting another review by commenting `auggie review` on your PR.


# Adding Context with MCP
Source: https://docs.augmentcode.com/codereview/mcp-context

Connect Augment Code Review to external context sources through Model Context Protocol.

## Configuring Model Context Protocol (MCP) Servers

Administrators can connect Augment Code Review to external context sources through Model Context Protocol (MCP). MCP servers provide additional context to the code review agent, such as access to documentation, APIs, databases, or other external systems that can help improve review quality.

To configure MCP servers, visit [MCP for Code Review](https://app.augmentcode.com/settings/code-review/mcp).

### Types of MCP Servers

Augment Code Review supports both remote and local MCP servers:

* **Remote MCP servers** run remotely and are hosted by providers. Once you add a remote MCP server, you may need to complete an OAuth flow to authenticate before it can be used by the code review agent.
* **Local MCP servers** run in their own environment within the code review agent's workspace. You can specify environment variables for local servers when adding them. Environment variables are write-only and can only be overwritten or removed (not viewed) after the server has been added.

### Adding MCP Servers

There are three ways to add MCP servers to Code Review:

#### 1. Add Local MCP Server (+ MCP)

To add a local MCP server:

1. Navigate to [MCP for Code Review](https://app.augmentcode.com/settings/code-review/mcp)
2. Click **+ MCP** to add a local server
3. Enter the following information:
   * **Name**: A descriptive name for your MCP server
   * **Command**: The executable command to run the server
   * **Arguments**: Command-line arguments (optional)
4. Add environment variables if needed:
   * Click **+ Environment Variable**
   * Enter the variable name and value
   * Repeat for additional variables
5. Click **Add Server** to save

<Note>
  Environment variables for local MCP servers are stored securely and cannot be viewed after saving. You can only overwrite or remove them.
</Note>

#### 2. Add Remote MCP Server (+ Remote MCP)

To add a remote MCP server:

1. Navigate to [MCP for Code Review](https://app.augmentcode.com/settings/code-review/mcp)
2. Click **+ Remote MCP** to add a remote server
3. Enter the following information:
   * **Name**: A descriptive name for your MCP server
   * **URL**: The full URL of the remote MCP server (e.g., `https://mcp.example.com`)
4. Click **Add Server**
5. If the server requires OAuth authentication, you'll be redirected to complete the authentication flow
6. After successful authentication, you'll be redirected back to the settings page

Remote MCP servers that require authentication will show a status indicator:

* **Connected** (green): Server is authenticated and ready to use
* **Authenticate** (yellow): Server needs authentication or re-authentication

#### 3. Import from JSON

To import MCP server configurations from a JSON file:

1. Navigate to [MCP for Code Review](https://app.augmentcode.com/settings/code-review/mcp)
2. Click **Import from JSON**
3. Paste your JSON configuration in the format:
   ```json theme={null}
   {
     "mcpServers": {
       "server-name": {
         "command": "npx",
         "args": ["-y", "@example/mcp-server"],
         "env": {
           "API_KEY": "your-api-key"
         }
       }
     }
   }
   ```
4. Click **Import** to add the servers

<Note>
  The JSON format matches the structure used in Augment's settings.json file, making it easy to share configurations across your team.
</Note>

### Managing MCP Servers

Once added, MCP servers appear in the "Configured MCP Servers" list. For each server, you can:

* **View status**: See if the server is connected or needs authentication
* **Re-authenticate**: Click the **Authenticate** button for remote servers that need re-authentication
* **Remove**: Click the trash icon to remove a server from Code Review

All configured MCP servers are available to the code review agent when analyzing pull requests.


# Using Augment Code Review
Source: https://docs.augmentcode.com/codereview/overview

A native GitHub experience to catch critical issues, comment on pull requests, and collaborate on fixes.

## Quickstart

<Tabs>
  <Tab title="New Users">
    <Steps>
      <Step title="Create an Augment Account">
        Visit [augmentcode.com](https://www.augmentcode.com) and click **Sign Up**. Complete registration with your email address, verify your email, and accept the terms of service during onboarding.
      </Step>

      <Step title="Connect GitHub to Configure your Repos for Code Review">
        Log in to [app.augmentcode.com](https://app.augmentcode.com), navigate to **Settings** → **Code Review** → **Configuration**, and click **Connect GitHub**. You'll be redirected to GitHub to authorize the app. Select the repositories you want to grant access to (all repositories or specific repos) and click **Install & Authorize**.
      </Step>

      <Step title="Set Code Review to Automatic or Manual">
        Return to [app.augmentcode.com](https://app.augmentcode.com), Under **Configuration**, Find the repository you want to enable. Under **Set Review Trigger**, choose **Automatic Review** for instant feedback on every PR when marked "ready for review", or **Manual Review** to trigger reviews by commenting `auggie review` on PRs.
      </Step>

      <Step title="Submit Your First Review">
        Create a pull request on GitHub in any enabled repository. For automatic reviews, mark the PR as "ready for review" and Augment will analyze it within minutes. For manual reviews, add a comment with `auggie review` to trigger the analysis.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Enterprise Plan" icon="building">
    <Steps>
      <Step title="Contact Your Enterprise Administrator">
        Before using Code Review, your Enterprise Plan administrator must enable the feature for your organization. Request access to specific repositories or organization-wide access, and confirm any custom enterprise policies or guidelines. Provide your GitHub organization name and list of repositories you want to enable.
      </Step>

      <Step title="Install the Augment GitHub App">
        If not already installed, navigate to [app.augmentcode.com/settings/code-review](https://app.augmentcode.com/settings/code-review) and click **Connect GitHub**. Select your organization (requires organization admin permissions), choose repository access level, and click **Install & Authorize**. See [Setup Guide for Enterprise](/codereview/setup-guide-enterprise) for detailed instructions.
      </Step>

      <Step title="Configure Repository Access">
        **For Admins:** In Code Review settings, enable or disable code review for specific repositories and configure per-repository settings (automatic review on PR ready, custom guidelines path). **For Non-Admins:** Contact your administrator to request access to additional repositories.
      </Step>

      <Step title="Start Using Code Review">
        Create a pull request in an enabled repository. For automatic reviews, mark the PR as "ready for review". For manual reviews, comment `auggie review`. Code Review will analyze and post review comments. Address feedback and use the **Fix with Augment** button to resolve issues in your IDE.
      </Step>
    </Steps>

    <Card title="Setup Guide for Enterprise Plan" icon="gear" href="/codereview/setup-guide-enterprise">
      Enterprise Plan administrators can configure Augment Code Review and grant repository access on GitHub.
    </Card>
  </Tab>

  <Tab title="All Other Plans" icon="star">
    Follow these steps if you are on an Indie, Standard, or Max plan.

    <Steps>
      <Step title="Connect GitHub to Configure your Repos for Code Review">
        Visit [app.augmentcode.com/settings/code-review](https://app.augmentcode.com/settings/code-review) and log in. Click **Connect GitHub to Get Started** to install the Augment GitHub App. You'll be redirected to GitHub to authorize the app and select repositories. Choose **All repositories** for organization-wide access or **Only select repositories** for specific repos, then click **Install & Authorize**.
      </Step>

      <Step title="Set Code Review to Automatic or Manual">
        As an Administrator, control when Code Review triggers. Navigate to **[Settings](https://app.augmentcode.com/settings/code-review)** → **Code Review** → **Configuration**. Under **Repositories**, use **Set Review Trigger**, to select  **Automatic Review** for instant feedback on every PR when marked "ready for review", or **Manual Review** to trigger reviews by commenting `auggie review` on PRs.
      </Step>

      <Step title="Start Reviewing Pull Requests">
        Create or open a pull request in GitHub. For automatic reviews, mark the PR as "ready for review". For manual reviews, comment `auggie review`, `augment review`, or `augmentcode review`. Code Review will add 👀 to show it's reviewing and post comments on any issues found.
      </Step>
    </Steps>

    <Card title="Setup Guide for All Other Plans" icon="star" href="/codereview/setup-guide-otherplans">
      Learn more about setting up Augment Code Review for Indie, Standard, and Max plans.
    </Card>
  </Tab>
</Tabs>

***

## Context powered code reviews focus on high-impact issues

Augment Code Review prioritizes high signal-to-noise ratio by focusing on high-impact issues:

* **Bugs**: Logic errors, edge cases, and potential runtime issues
* **Security concerns**: Vulnerabilities, unsafe operations, and data exposure risks
* **Correctness**: Null handling and error management
* **Cross-system problems**: Breaking changes, API compatibility, and integration issues

The agent avoids low-value style nags and focuses on objective issues by gathering context from multiple sources:

* **PR Contents**: The agent analyzes the complete code diff to understand what changed and why.

* **Entire Repository**: Through Augment's Context Engine, the agent has access to your full codebase, enabling it to identify cross-system impacts and maintain consistency with existing patterns.

* **PR Title and Description**: More detailed PR descriptions help the agent provide better, more targeted reviews. Include information about:
  * What the PR accomplishes
  * Why the changes were made
  * Any special considerations or context

***

## Best Practices

**Write detailed PR descriptions**: The more context you provide in your PR title and description, the better the agent can understand your intent and provide relevant feedback.

**Use custom guidelines**: Define repository-specific review guidelines to help the agent focus on your team's priorities and domain-specific concerns.

**Provide feedback**: Give feedback on comments using the thumbs up emoji to indicate whether the comment is useful or thumbs down if the comment was not helpful.

**Ask for a follow-up review**: If you make significant changes to the PR and want another review, then ask for a follow-up review by commenting on your PR with the same comments as a manual request: `auggie review`, `augment review`, or `augmentcode review`. The agent will add 👀 to the comment so you know it is reviewing the PR.


# Providing Feedback
Source: https://docs.augmentcode.com/codereview/providing-feedback

Learn how to provide feedback on Augment Code Review comments directly in GitHub.

## Providing feedback

You can provide in product feedback directly in GitHub by reacting with a thumbs up or thumbs down emoji to the inline comment left by Augment Code Review.

<img alt="Code Review Feedback using GitHub Reactions" />


# Adding Review Guidelines
Source: https://docs.augmentcode.com/codereview/review-guidelines

Configure custom guidelines to help Augment Code Review focus on specific areas and domain knowledge.

## Tell Augment Code Review to check specific areas with guidelines

Some domain knowledge cannot be inferred from code alone. Tell Augment Code Review exactly what to check by adding custom guidelines. Guidelines are most relevant for repositories that contain multiple distinct domains and should be captured as custom review guidelines. Tell Augment Code Review to check specific areas like security vulnerabilities or inside particular directories when relevant. Augment Code Review allows you to outline these special guidelines per repository. Describe any areas of focus using a yaml file entitled code\_review\_guidelines.yaml inside the .augment folder at the repository root:

`<repo-root>/.augment/code_review_guidelines.yaml`

Scope guidelines to the appropriate sub-directories and focus on objective issues that can cause bugs, expose vulnerabilities, etc. and less on stylistic or subjective things. Augment Code Review uses a unique yaml file instead of relying on markdown guideline files like Agents.md, etc. because it allows the agent to cite a guideline if it was used for a particular comment, and compute per-guideline analytics.

### Example Augment Code Review Guidelines

For a complete working example, see the [Code Review Best Practices](https://github.com/augmentcode/code-review-best-practices) repository.

```yaml theme={null}
# Guidelines exclusive to augmentcode/auggie

areas:
  databases:
    description: "Data and Database related rules"
    globs:
      - "**"
    rules:
      - id: "no_pii_in_bigquery"
        description: "Never store PII data in BigQuery tables."
        severity: "high"
      - id: "no_guid_keys"
        description: "GUID foreign keys can slow lookups"
        severity: "medium"

  memory_safety:
    description: "Ensure Memory Safety"
    globs:
      - "kernel/**"
    rules:
      - id: "avoid_unsafe_rust"
        description: "Avoid unsafe Rust operations."
        severity: "high"
```

<Note>
  Common **globs** or pattern matching syntax:

  * `**` - Matches any number of directories (recursive wildcard)
    * Example: `**/test.py` matches `test.py`, `src/test.py`, `src/utils/test.py`, etc.
  * `*` - Matches any sequence of characters within a single directory level
    * Example: `*.py` matches `file.py`, `main.py` but not `src/main.py`
  * `?` - Matches exactly one character
    * Example: `test?.py` matches `test1.py`, `testA.py` but not `test10.py`
</Note>

* **Rules:** Areas can contain more than one rule. Each rule contains:
  * **ID**: Double quoted unique identifier
  * **Description**: Double quoted message summarizing intent of the rule
  * **Severity**: Expects double quoted "high", "medium" or "low". Sets the priority of review by Augment Code Review

### Referencing Existing Rules Files

You can add a custom rule that references an existing rules file (like `Agents.md`) to incorporate those guidelines into your code review process. This allows you to reuse existing documentation and standards without duplicating content.

However, it is recommended to use the YAML format to track guidelines, as this enables Augment Code Review to cite specific guidelines in comments and compute per-guideline analytics.

## Files Automatically Skipped During Review

Augment Code Review automatically skips certain file types that are not typically code files. This helps focus the review on meaningful code changes and avoids wasting time on binary files, generated content, and other non-reviewable assets.

<Accordion title="File Extensions Automatically Ignored">
  The following file extensions are automatically skipped during code review:

  **Archive files:**

  * `.bz2`, `.gz`, `.xz`, `.zip`, `.7z`, `.rar`, `.zst`, `.tar`, `.jar`, `.war`, `.nar`

  **Image files:**

  * `.ico`, `.svg`, `.jpeg`, `.jpg`, `.png`, `.gif`, `.bmp`, `.tiff`, `.webm`

  **Font files:**

  * `.ttf`, `.otf`, `.woff`, `.woff2`, `.eot`

  **Document files:**

  * `.pdf`, `.doc`, `.docx`, `.xls`, `.xlsx`, `.ppt`, `.pptx`

  **Data files:**

  * `.csv`, `.tsv`, `.dat`, `.db`, `.parquet`

  **System files:**

  * `.DS_Store`, `.tags`

  **Cscope files:**

  * `.cscope.files`, `.cscope.out`, `.cscope.in.out`, `.cscope.po.out`

  **Log and output files:**

  * `.log`, `.map`, `.out`, `.sum`, `.work`, `.md5sum`

  **3D and graphics files:**

  * `.tga`, `.dds`, `.psd`, `.fbx`, `.obj`, `.blend`, `.dae`, `.gltf`

  **Shader files:**

  * `.hlsl`, `.glsl`

  **Game engine files:**

  * `.unity`, `.umap`, `.prefab`, `.mat`, `.shader`, `.shadergraph`, `.sav`, `.scene`, `.asset`

  **Python compiled files:**

  * `.pyc`, `.pyd`, `.pyo`, `.pkl`, `.pickle`

  **Protocol buffer files:**

  * `.pb.go`, `.pb.gw.go`

  **Terraform files:**

  * `.tfstate`, `.tfstate.backup`

  **Minified files:**

  * `.min.js`, `.min.js.map`, `.min.js.css`

  **Lock and dependency files:**

  * `.lock`, `.lockb`, `.lockfile`

  **Debug and trace files:**

  * `.trace`, `.dump`

  **Backup files:**

  * `.bak`, `.backup`

  **Database files:**

  * `.sql.gz`
</Accordion>

<Accordion title="File Patterns Automatically Ignored">
  In addition to specific extensions, the following file patterns are also skipped:

  * `*lock.json`, `*lock.yaml`, `*lock.yml` - Lock files with specific patterns
  * `go.sum` - Go module checksum files
  * `*.bundle.js`, `*.chunk.js` - JavaScript bundle files
  * `**/generated/**`, `**/*.generated.*` - Generated files
  * `*_snapshot.json` - Snapshot files
</Accordion>

## Customizing Files to Skip

You can add additional files or paths to skip during code review by specifying them in your custom guidelines file. This is useful for repository-specific generated files, large data files, or other content that shouldn't be reviewed.

### Adding Custom File Paths to Ignore

Use the `file_paths_to_ignore` section in your `code_review_guidelines.yaml` file. This field supports doublestar glob patterns for flexible matching.

```yaml theme={null}
# File paths to ignore during code review (supports doublestar glob patterns)
file_paths_to_ignore:
  - "services/code_review/**/category_taxonomy.json"
  - "**/generated/**"
  - "**/*.generated.ts"
  - "dist/**"
  - "build/**"
```

<Accordion title="Complete Example with Custom Ignores">
  ```yaml theme={null}
  # Guidelines for myproject

  # Custom files to skip during review
  file_paths_to_ignore:
    - "services/code_review/**/category_taxonomy.json"
    - "**/*.generated.graphql"
    - "public/assets/**"

  areas:
    databases:
      description: "Data and Database related rules"
      globs:
        - "**"
      rules:
        - id: "no_pii_in_bigquery"
          description: "Never store PII data in BigQuery tables."
          severity: "high"
  ```
</Accordion>


# Setup Guide for Enterprise
Source: https://docs.augmentcode.com/codereview/setup-guide-enterprise

Configure Augment Code Review for Enterprise accounts with multi-organization support.

## Using Augment Code Review natively inside of GitHub

Augment Code Review helps professional software teams complete code-reviews faster inside GitHub while also catching more critical bugs before they hit production. Backed by Augment's industry-leading Context Engine, the agent understands your codebase at a deep level, providing reviews that are more meaningful and account for codebase-wide effects. Augment prioritizes high signal-to-noise ratio by focusing on high-impact issues like bugs, security concerns, correctness, and cross-system problems while avoiding low-value style nags.

<Note>
  Augment Code Review relies on the Augment GitHub App which is only compatible with GitHub Enterprise Cloud and github.com. GitHub Enterprise Server is not currently supported.
</Note>

## About the installation process

Visit [app.augmentcode.com/settings/code-review](https://app.augmentcode.com/settings/code-review) and log in. Settings are accessible to all members of the Enterprise plan, but only configurable for Administrators of the Enterprise plan. If you aren't sure if you are an Administrator, please contact your solutions team.

### Configure Repo Access inside of the Augment GitHub App

Before you can configure repositories, click on "Connect GitHub" to install the Augment GitHub App. This will redirect you to GitHub to provide permissions for all the repos you grant Augment Code Review to engage.

<img alt="Code Review Settings Configure button" />

If your firewall configuration, allowlist or network policy requires a static IP for this integration, please refer to our [static IP address](https://docs.augmentcode.com/setup-augment/static-ip-support#allow-augment-traffic-from-static-ips) documentation.

<AccordionGroup>
  <Accordion title="Who can install the Augment GitHub App?">
    To install the Augment GitHub App, you will need to be an Administrator of your GitHub organization. To find who the Administrators are, visit your GitHub organization settings page and click on "People." Administrators are listed under "Owners."

    <img alt="GitHub Admins" />
  </Accordion>
</AccordionGroup>

Once you finish installing the GitHub app, you should see a green checkmark with the text "All set!". Then, back in the Augment Code Review Settings, should now show a green "Installed" badge. If you do not see either of these, you may need to uninstall the app through GitHub and reinstall it. See [Troubleshooting](/codereview/troubleshooting#stuck-on-install-button) for more help.

<img alt="GitHub App Installed" />

### Permissions requested by the Augment GitHub App:

* Contents, read-only: Clone repositories

* Pull Requests, read and write: Read pull requests and post comments to pull requests

* Issues, read-only: Read top-level PRs / Issues

* Organization Members, read-only: Read members of an organization, to distinguish internal and external users and their access levels to Augment features

Organization owners and repository admins can install the app directly; others will need owner approval. See [GitHub documentation](https://docs.github.com/en/apps/using-github-apps/installing-a-github-app-from-a-third-party) for details. If your organization uses [Augment for Slack,](https://docs.augmentcode.com/setup-augment/install-slack-app) the same selections will apply to both Augment for Slack and Augment Code Review.

<img alt="Installing the GitHub app on a single repository" />

You can modify repository access anytime in the Augment GitHub App settings.

### Configuring Triggers Per Repository

As the Administrator, you control when Augment Code Review triggers via [Settings](https://app.augmentcode.com/settings/code-review). Look for "Set Review Trigger" to the right of the repository name.

* **Automatic**: Augment Code Review will automatically review and post a comment as soon as the PR is opened for review in GitHub. Use it when your teams want immediate feedback on all pull requests.

* **Manual Command**: Augment Code Review is only triggered when someone comments on the PR with any of the following:  `auggie review`, `augment review`, or `augmentcode review` on GitHub. Use it when you want full control over when a review happens.

* **Disabled**: Augment Code Review will not run on the repository.

<img alt="Trigger Types" />

If the repo is set to "Automatic" or "Manual Command", to run additional rounds of reviews on a subsequent commit of any PR, you can use the same manual trigger keywords (`auggie review`, `augment review`, or `augmentcode review`).

On public repositories, reviews are only triggered for PRs whose authors are members of the GitHub organization, outside collaborators to the organization or repository, or contributors to that repository.

## Next Steps

Now that you've completed the basic setup, explore these additional features to get the most out of Augment Code Review:

<CardGroup>
  <Card title="Adding Another Organization" icon="building" href="/codereview/adding-another-organization">
    Configure Code Review across multiple GitHub organizations
  </Card>

  <Card title="Review Guidelines" icon="list-check" href="/codereview/review-guidelines">
    Set custom guidelines to focus reviews on specific areas
  </Card>

  <Card title="MCP Context" icon="plug" href="/codereview/mcp-context">
    Connect external context sources via Model Context Protocol
  </Card>

  <Card title="User Access" icon="users" href="/codereview/user-access">
    Manage which users can trigger Code Review
  </Card>

  <Card title="Analytics Dashboard" icon="chart-line" href="/codereview/analytics-dashboard">
    Track metrics and measure Code Review impact
  </Card>

  <Card title="Providing Feedback" icon="thumbs-up" href="/codereview/providing-feedback">
    Learn how to provide feedback on reviews
  </Card>
</CardGroup>

## Need Help?

If you encounter any issues during setup, check out our [Troubleshooting](/codereview/troubleshooting) guide.


# Setup Guide for All Other Plans
Source: https://docs.augmentcode.com/codereview/setup-guide-otherplans

Get started with Augment Code Review for Indie, Standard and Max plans.

## Using Augment Code Review

Augment Code Review is available as an add-on feature for individuals and teams. It provides automated code review directly in GitHub, helping you catch bugs and improve code quality before merging. Backed by Augment’s industry-leading Context Engine, the agent understands your codebase at a deep level, providing reviews that are more meaningful and account for codebase-wide effects. Augment prioritizes high signal-to-noise ratio by focusing on high-impact issues like bugs, security concerns, correctness, and cross-system problems while avoiding low-value style nags.

## About the installation process

Visit [app.augmentcode.com/settings/code-review](https://app.augmentcode.com/settings/code-review) and log in. Settings are accessible to all [Team members](https://docs.augmentcode.com/teams/teams-admin-guide), but only configurable by Administrators of the plan.

### Configure Repo Access inside of the Augment GitHub App

Administrators can configure repositories by clicking "Connect GitHub" to launch the Augment GitHub App. This will redirect you to GitHub to provide permissions for all the repos you grant Augment Code Review to engage.

<img alt="Code Review Settings Configure button" />

If your firewall configuration, allowlist or network policy requires a static IP for this integration, please refer to our [static IP address](https://docs.augmentcode.com/setup-augment/static-ip-support#allow-augment-traffic-from-static-ips) documentation.

<AccordionGroup>
  <Accordion title="Who can install the Augment GitHub App?">
    To install the Augment GitHub App, you will need to be an Administrator of your GitHub organization. To find who the Administrators are, visit your GitHub organization settings page and click on "People." Administrators are listed under "Owners."

    <img alt="GitHub Admins" />
  </Accordion>
</AccordionGroup>

Once you finish installing the GitHub app, you should see a green checkmark with the text "All set!". Then, back in the Augment Code Review Settings, should now show a green "Installed" badge. If you do not see either of these, you may need to uninstall the app through GitHub and reinstall it. See [Troubleshooting](/codereview/troubleshooting#stuck-on-install-button) for more help.

<img alt="GitHub App Installed" />

### Permissions requested by the Augment GitHub App:

* Contents, read-only: Clone repositories

* Pull Requests, read and write: Read pull requests and post comments to pull requests

* Issues, read-only: Read top-level PRs / Issues

* Organization Members, read-only: Read members of an organization, to distinguish internal and external users and their access levels to Augment features

Organization owners and repository admins can install the app directly; others will need owner approval. See [GitHub documentation](https://docs.github.com/en/apps/using-github-apps/installing-a-github-app-from-a-third-party) for details.

<img alt="Installing the GitHub app on a single repository" />

You can modify repository access anytime in the Augment GitHub App settings.

### Configuring Triggers Per Repository

As the Administrator, you control when Augment Code Review triggers via [Settings](https://app.augmentcode.com/settings/code-review). Look for "Set Review Trigger" to the right of the repository name.

* **Automatic**: Augment Code Review will automatically review and post a comment as soon as the PR is opened for review in GitHub. Use it when your teams want immediate feedback on all pull requests.

* **Manual Command**: Augment Code Review is only triggered when someone comments on the PR with any of the following:  `auggie review`, `augment review`, or `augmentcode review` on GitHub. Use it when you want full control over when a review happens.

* **Disabled**: Augment Code Review will not run on the repository.

<img alt="Trigger Types" />

If the repo is set to "Automatic" or "Manual Command", to run additional rounds of reviews on a subsequent commit of any PR, you can use the same manual trigger keywords (`auggie review`, `augment review`, or `augmentcode review`).

On public repositories, reviews are only triggered for PRs whose authors are members of the GitHub organization, outside collaborators to the organization or repository, or contributors to that repository.

<Note>
  If you are an Enterprise customer, please refer to the [Enterprise setup guide](/codereview/setup-guide-enterprise) for additional information.
</Note>

## Questions?

If you have questions about Augment Code Review or want to learn more about Enterprise features:

* Visit our [Support Center](https://support.augmentcode.com/)
* Join our [Subreddit](https://www.reddit.com/r/AugmentCodeAI/)
* Contact Us [Augment Support](https://portal.usepylon.com/augment-code/forms/augment-support)

## Related Resources

* [Code Review Overview](/codereview/overview) - Learn about Code Review features
* [Fix with Augment](/codereview/fix-with-augment) - Automatically fix issues in your IDE
* [Setup Guide for Enterprise](/codereview/setup-guide-enterprise) - Full setup instructions for Enterprise


# Troubleshooting
Source: https://docs.augmentcode.com/codereview/troubleshooting

Common issues and solutions for Augment Code Review setup and configuration.

## Known issues and Remediations

### Stuck on Install button

If you still see the "Install" button on the Augment Code Review Settings page, then the Augment GitHub App installation failed. You will need to uninstall the Augment GitHub App from your organization and then reinstall it. Make sure the person installing the GitHub app has an Augment account and they see the "All set!" text after installing the app.

<Steps>
  <Step title="Navigate to the Augment GitHub App settings page on GitHub">
    Follow the steps on [GitHub Docs](https://docs.github.com/en/apps/using-github-apps/reviewing-and-modifying-installed-github-apps#navigating-to-the-github-app-you-want-to-review-or-modify) to modify the Augment GitHub App installation.
  </Step>

  <Step title="Uninstall the Augment GitHub App from your organization">
    In the Danger zone section, click on "Uninstall"
  </Step>

  <Step title="Reinstall the Augment GitHub App">
    Follow the steps in [Configure Repo Access](/codereview/setup-guide-enterprise#configure-repo-access-inside-of-the-augment-github-app) again to install the app
  </Step>
</Steps>

### Unable to see the repositories from Organization just added

If you are unable to see the repositories from an organization you just added, then the Augment GitHub App installation failed for that organization. You will need to uninstall the Augment GitHub App from your organization and then reinstall it. Make sure the GitHub administrator installing the GitHub app has an Augment account and they see the "All set!" text after installing the app.

<Steps>
  <Step title="Navigate to the Augment GitHub App settings page on GitHub">
    Follow the steps on [GitHub Docs](https://docs.github.com/en/apps/using-github-apps/reviewing-and-modifying-installed-github-apps#navigating-to-the-github-app-you-want-to-review-or-modify) to modify the Augment GitHub App installation.
  </Step>

  <Step title="Uninstall the Augment GitHub App from your organization">
    In the Danger zone section, click on "Uninstall"
  </Step>

  <Step title="Reinstall the Augment GitHub App">
    Follow the steps in [Configure Repo Access](/codereview/setup-guide-enterprise#configure-repo-access-inside-of-the-augment-github-app) again to install the app
  </Step>
</Steps>


# User Access
Source: https://docs.augmentcode.com/codereview/user-access

Manage which GitHub users can trigger Augment Code Review with allowlist mode.

## User Access

Enterprise Plan administrators are able to specify a list of GitHub users who can trigger Augment Code Review by turning on **Allowlist Mode**.

When Allowlist Mode is active, only users in the allowlist will be able to trigger Augment Code Review. Automatic and manual reviews will be disabled for all other users. This is useful for organizations that want to limit access to the feature to a select group of users.

Administrators can manage permissions at [User Access for Code Review](https://app.augmentcode.com/settings/code-review/user-access).


# Context Engine MCP
Source: https://docs.augmentcode.com/context-services/mcp/overview

Plug Context Engine into any agent via the Model Context Protocol

## Quickstart Guides

Get started with Context Engine MCP in your favorite AI tool:

<CardGroup>
  <Card title="Claude Code" icon="terminal" href="/context-services/mcp/quickstart-claude-code">
    Set up Context Engine MCP with Claude Code
  </Card>

  <Card title="Codex" icon="terminal" href="/context-services/mcp/quickstart-codex">
    Set up Context Engine MCP with OpenAI Codex CLI
  </Card>

  <Card title="Cursor" icon="code" href="/context-services/mcp/quickstart-cursor">
    Set up Context Engine MCP with Cursor
  </Card>

  <Card title="Zed" icon="code" href="/context-services/mcp/quickstart-zed">
    Set up Context Engine MCP with Zed
  </Card>

  <Card title="GitHub Copilot" icon="github" href="/context-services/mcp/quickstart-github-copilot">
    Set up Context Engine MCP with GitHub Copilot
  </Card>

  <Card title="OpenCode" icon="code" href="/context-services/mcp/quickstart-open-code">
    Set up Context Engine MCP with OpenCode
  </Card>

  <Card title="Kilo Code" icon="code" href="/context-services/mcp/quickstart-kilo">
    Set up Context Engine MCP with Kilo Code
  </Card>

  <Card title="Kiro" icon="code" href="/context-services/mcp/quickstart-kiro">
    Set up Context Engine MCP with Kiro
  </Card>

  <Card title="AntiGravity" icon="rocket" href="/context-services/mcp/quickstart-anti-gravity">
    Set up Context Engine MCP with AntiGravity
  </Card>

  <Card title="Gemini CLI" icon="terminal" href="/context-services/mcp/quickstart-gemini-cli">
    Set up Context Engine MCP with Gemini CLI
  </Card>

  <Card title="Droid (Factory.AI)" icon="robot" href="/context-services/mcp/quickstart-droid">
    Set up Context Engine MCP with Droid
  </Card>
</CardGroup>


# Quickstart (AntiGravity)
Source: https://docs.augmentcode.com/context-services/mcp/quickstart-anti-gravity

Get started with Augment Context Engine MCP in AntiGravity in minutes

## Quick Start with AntiGravity

### 1. Install Auggie CLI

```bash theme={null}
npm install -g @augmentcode/auggie@latest
```

### 2. Sign in to Augment

```bash theme={null}
auggie login
```

This will open a browser window for authentication.

### 3. Configure the MCP server in AntiGravity

* Click the MCP server icon
  <img alt="MCP server icon" />
* Click manage MCP server
  <img alt="Manage MCP server" />
* Click View raw config
  <img alt="View raw config" />

Paste this configuration:

```json theme={null}
{
  "mcpServers": {
    "augment-context-engine": {
      "command": "auggie",
      "args": ["--mcp", "--mcp-auto-workspace"]
    }
  }
}
```

### 4. Test the integration

```
Prompt: "What is this project? Please use codebase retrieval tool to get the answer."
```

AntiGravity should confirm it has access to the `codebase-retrieval` tool.

<img alt="AntiGravity test" />


# Quickstart (Claude Code)
Source: https://docs.augmentcode.com/context-services/mcp/quickstart-claude-code

Get started with Augment Context Engine MCP in Claude Code in minutes

## Quick Start with Claude Code

### 1. Install Auggie CLI

```bash theme={null}
npm install -g @augmentcode/auggie@latest
```

### 2. Sign in to Augment

```bash theme={null}
auggie login
```

This will open a browser window for authentication.

### 3. Configure the MCP server in Claude Code

Add the MCP server to user scope (available in all projects):

```bash theme={null}
claude mcp add-json auggie-mcp --scope user '{"type":"stdio","command":"auggie","args":["--mcp","--mcp-auto-workspace"]}'
```

Or add to project scope (only available in the current project):

```bash theme={null}
claude mcp add-json auggie-mcp --scope project '{"type":"stdio","command":"auggie","args":["--mcp","--mcp-auto-workspace"]}'
```

### 4. Test the integration

```bash theme={null}
claude --print "Do you have access to the Augment codebase retrieval tool? Answer in one sentence."
```

Claude should confirm it has access to the `codebase-retrieval` tool.

## Advanced: Non-Interactive Setup

For non-interactive environments like CI/CD pipelines, GitHub Actions, or automated scripts where you cannot run `auggie login` interactively, you can configure authentication using environment variables.

### 1. Get your authentication token

```bash theme={null}
auggie token print
```

This will output something like:

```
TOKEN={"accessToken":"your-access-token","tenantURL":"your-tenant-url","scopes":["read","write"]}
```

Copy the `accessToken` value (the long string after `"accessToken":"`) and the `tenantURL` value.

### 2. Configure with environment variables

```bash theme={null}
claude mcp add-json auggie-mcp --scope user '{"type":"stdio","command":"auggie","args":["--mcp","--mcp-auto-workspace"],"env":{"AUGMENT_API_TOKEN":"your-access-token","AUGMENT_API_URL":"your-tenant-url"}}'
```

Replace `your-access-token` and `your-tenant-url` with the values from step 1.


# Quickstart (Codex)
Source: https://docs.augmentcode.com/context-services/mcp/quickstart-codex

Get started with Augment Context Engine MCP in OpenAI Codex CLI in minutes

## Quick Start with Codex

### 1. Install Auggie CLI

```bash theme={null}
npm install -g @augmentcode/auggie@latest
```

### 2. Sign in to Augment

```bash theme={null}
auggie login
```

This will open a browser window for authentication.

### 3. Configure the MCP server in Codex

Add the MCP server using the Codex CLI:

```bash theme={null}
codex mcp add codebase-retrieval -- auggie --mcp --mcp-auto-workspace
```

The `--mcp-auto-workspace` flag automatically detects your workspace when using Codex.

### 4. Test the integration

Run Codex and prompt it with:

```
"What is this project? Please use the codebase-retrieval tool to get the answer."
```

Codex should confirm it has access to the `codebase-retrieval` tool.

## Advanced: Non-Interactive Setup

For non-interactive environments like CI/CD pipelines, GitHub Actions, or automated scripts where you cannot run `auggie login` interactively, you can configure authentication using environment variables.

### 1. Get your authentication token

```bash theme={null}
auggie token print
```

This will output something like:

```
TOKEN={"accessToken":"your-access-token","tenantURL":"your-tenant-url","scopes":["read","write"]}
```

Copy the `accessToken` value (the long string after `"accessToken":"`) and the `tenantURL` value.

### 2. Configure with environment variables

```bash theme={null}
codex mcp add codebase-retrieval --env AUGMENT_API_TOKEN=your-access-token --env AUGMENT_API_URL=your-tenant-url -- auggie --mcp --mcp-auto-workspace
```

Replace `your-access-token` and `your-tenant-url` with the values from step 1.


# Quickstart (Cursor)
Source: https://docs.augmentcode.com/context-services/mcp/quickstart-cursor

Get started with Augment Context Engine MCP in Cursor in minutes

## Quick Start with Cursor

### 1. Install Auggie CLI

```bash theme={null}
npm install -g @augmentcode/auggie@latest
```

### 2. Sign in to Augment

```bash theme={null}
auggie login
```

This will open a browser window for authentication.

### 3. Configure the MCP server in Cursor

* Go in settings (top right)
  <img alt="Cursor settings" />
* Click on Tools & MCP on the left menu then **New MCP Server**
  <img alt="Cursor MCP" />

Paste this configuration:

```json theme={null}
{
  "mcpServers": {
    "augment-context-engine": {
      "type": "local",
      "command": "auggie",
      "args": ["--mcp", "--mcp-auto-workspace"],
      "enabled": true
    }
  }
}
```

### 4. Test the integration

```
Prompt: "What is this project? Please use codebase retrieval tool to get the answer."
```

Cursor should confirm it has access to the `codebase-retrieval` tool.

<img alt="Cursor test" />

See [MCP Server Mode](/cli/reference#mcp-server-mode) for more options.


# Quickstart (Droid)
Source: https://docs.augmentcode.com/context-services/mcp/quickstart-droid

Get started with Augment Context Engine MCP in Droid in minutes

## Quick Start with Droid

### 1. Install Auggie CLI

```bash theme={null}
npm install -g @augmentcode/auggie@latest
```

### 2. Sign in to Augment

```bash theme={null}
auggie login
```

This will open a browser window for authentication.

### 3. Configure the MCP server in Droid

Add the Augment Context Engine MCP server:

```bash theme={null}
droid mcp add augment-code "auggie" --mcp --mcp-auto-workspace
```

### 4. Test the integration

```
Prompt: "Do you have access to the Augment codebase retrieval tool?"
```

Droid should confirm it has access to the `codebase-retrieval` tool.

## Advanced: Non-Interactive Setup

For non-interactive environments like CI/CD pipelines, GitHub Actions, or automated scripts where you cannot run `auggie login` interactively, you can configure authentication using environment variables.

### 1. Get your authentication token

```bash theme={null}
auggie token print
```

This will output something like:

```
TOKEN={"accessToken":"your-access-token","tenantURL":"your-tenant-url","scopes":["read","write"]}
```

Copy the `accessToken` value (the long string after `"accessToken":"`) and the `tenantURL` value.

### 2. Configure with environment variables

```bash theme={null}
droid mcp add augment-code "auggie" --mcp --mcp-auto-workspace --env AUGMENT_API_TOKEN=your-access-token --env AUGMENT_API_URL=your-tenant-url
```

Replace `your-access-token` and `your-tenant-url` with the values from step 1.


# Quickstart (Gemini CLI)
Source: https://docs.augmentcode.com/context-services/mcp/quickstart-gemini-cli

Get started with Augment Context Engine MCP in Gemini CLI in minutes

## Quick Start with Gemini CLI

### 1. Install Auggie CLI

```bash theme={null}
npm install -g @augmentcode/auggie@latest
```

### 2. Sign in to Augment

```bash theme={null}
auggie login
```

This will open a browser window for authentication.

### 3. Configure the MCP server in Gemini CLI

Gemini CLI reads the MCP server configuration from a settings file. You can configure MCP servers at either the user level (applies to all projects) or project level (applies only to that specific project):

**Configuration file locations:**

* **User settings** (global):
  * macOS/Linux: `~/.gemini/settings.json`
  * Windows: `%USERPROFILE%\.gemini\settings.json`
* **Project settings** (optional): `.gemini/settings.json` in your project's root directory

Add the following configuration to your Gemini CLI settings file:

```json theme={null}
{
  "mcpServers": {
    "augment-context-engine": {
      "command": "auggie",
      "args": ["--mcp", "--mcp-auto-workspace"]
    }
  }
}
```

### 4. Test the integration

Prompt the Gemini CLI with:

```
Prompt: "What is this project? Please use codebase retrieval tool to get the answer."
```

Gemini CLI should confirm it has access to the `codebase-retrieval` tool.

## Advanced: Non-Interactive Setup

For non-interactive environments like CI/CD pipelines, GitHub Actions, or automated scripts where you cannot run `auggie login` interactively, you can configure authentication using environment variables.

### 1. Get your authentication token

```bash theme={null}
auggie token print
```

This will output something like:

```
TOKEN={"accessToken":"your-access-token","tenantURL":"your-tenant-url","scopes":["read","write"]}
```

Copy the `accessToken` value (the long string after `"accessToken":"`) and the `tenantURL` value.

### 2. Configure with environment variables

Add the `env` section to your configuration:

```json theme={null}
{
  "mcpServers": {
    "augment-context-engine": {
      "command": "auggie",
      "args": ["--mcp", "--mcp-auto-workspace"],
      "env": {
        "AUGMENT_API_TOKEN": "your-access-token",
        "AUGMENT_API_URL": "your-tenant-url"
      }
    }
  }
}
```

Replace `your-access-token` and `your-tenant-url` with the values from step 1.


# Quickstart (GitHub Copilot)
Source: https://docs.augmentcode.com/context-services/mcp/quickstart-github-copilot

Get started with Augment Context Engine MCP in GitHub Copilot in minutes

## Quick Start with GitHub Copilot

### 1. Install Auggie CLI

```bash theme={null}
npm install -g @augmentcode/auggie@latest
```

### 2. Sign in to Augment

```bash theme={null}
auggie login
```

This will open a browser window for authentication.

### 3. Configure the MCP server in GitHub Copilot

* Please create the following file **at the root** of your project: **.vscode/mcp.json**
* Paste this content inside and **Save**

```json theme={null}
{
  "servers": {
    "augmentcode": {
      "type": "stdio",
      "command": "auggie",
      "args": ["--mcp", "--mcp-auto-workspace"]
    }
  },
  "inputs": []
}
```

### 4. Test the integration

Prompt this in **AGENT MODE**: "What is this project? Please use codebase retrieval tool to get the answer."

Copilot should confirm it has access to the `codebase-retrieval` tool.

<img alt="Copilot test" />


# Quickstart (Kilo)
Source: https://docs.augmentcode.com/context-services/mcp/quickstart-kilo

Get started with Augment Context Engine MCP in Kilo in minutes

## Quick Start with Kilo

### 1. Install Auggie CLI

```bash theme={null}
npm install -g @augmentcode/auggie@latest
```

### 2. Sign in to Augment

```bash theme={null}
auggie login
```

This will open a browser window for authentication.

### 3. Configure the MCP server in Kilo

* Click the MCP server icon
  <img alt="Click the MCP server icon" />

* Click Edit Global MCP
  <img alt="Click Edit Global MCP" />

Paste this configuration:

```json theme={null}
{
  "mcpServers": {
    "augment-context-engine": {
      "command": "auggie",
      "type": "stdio",
      "args": ["--mcp", "--mcp-auto-workspace"],
      "disabled": false,
      "alwaysAllow": ["codebase-retrieval"]
    }
  }
}
```

### 4. Test the integration

Prompt: "What is this project? Please use codebase retrieval tool to get the answer."

Kilo should confirm it has access to the `codebase-retrieval` tool.

<img alt="Kilo test" />


# Quickstart (Kiro)
Source: https://docs.augmentcode.com/context-services/mcp/quickstart-kiro

Get started with Augment Context Engine MCP in Kiro in minutes

## Quick Start with Kiro

### 1. Install Auggie CLI

```bash theme={null}
npm install -g @augmentcode/auggie@latest
```

### 2. Sign in to Augment

```bash theme={null}
auggie login
```

This will open a browser window for authentication.

### 3. Configure the MCP server in Kiro

Open the command palette (`Cmd + Shift + P` on Mac, `Ctrl + Shift + P` on Windows/Linux) and select:

* **Kiro: Open workspace MCP config (JSON)** - For workspace-level configuration
* **Kiro: Open user MCP config (JSON)** - For user-level configuration

Paste this configuration:

```json theme={null}
{
  "mcpServers": {
    "Augment-Context-Engine": {
      "command": "auggie",
      "args": ["--mcp", "--mcp-auto-workspace"],
      "disabled": false,
      "autoApprove": ["codebase-retrieval"]
    }
  }
}
```

### 4. Test the integration

```
Prompt: "Do you have access to the Augment codebase retrieval tool?"
```

Kiro should confirm it has access to the `codebase-retrieval` tool.


# Quickstart (OpenCode)
Source: https://docs.augmentcode.com/context-services/mcp/quickstart-open-code

Get started with Augment Context Engine MCP in OpenCode in minutes

## Quick Start with OpenCode

### 1. Install Auggie CLI

```bash theme={null}
npm install -g @augmentcode/auggie@latest
```

### 2. Sign in to Augment

```bash theme={null}
auggie login
```

This will open a browser window for authentication.

### 3. Configure the MCP server in OpenCode

* Go to Folder: \~/.config/opencode/
* Create a file named: opencode.json

Paste this configuration:

```json theme={null}
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "augment-context-engine": {
      "type": "local",
      "command": ["auggie", "--mcp", "--mcp-auto-workspace"],
      "enabled": true
    }
  }
}
```

### 4. Test the integration

```
Prompt: "What is this project? Please use codebase retrieval tool to get the answer."
```

OpenCode should confirm it has access to the `codebase-retrieval` tool.

<img alt="OpenCode test" />

## Advanced: Non-Interactive Setup

For non-interactive environments like CI/CD pipelines, GitHub Actions, or automated scripts where you cannot run `auggie login` interactively, you can configure authentication using environment variables.

### 1. Get your authentication token

```bash theme={null}
auggie token print
```

This will output something like:

```
TOKEN={"accessToken":"your-access-token","tenantURL":"your-tenant-url","scopes":["read","write"]}
```

Copy the `accessToken` value (the long string after `"accessToken":"`) and the `tenantURL` value.

### 2. Configure with environment variables

Add the `env` section to your configuration:

```json theme={null}
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "augment-context-engine": {
      "type": "local",
      "command": ["auggie", "--mcp", "--mcp-auto-workspace"],
      "enabled": true,
      "env": {
        "AUGMENT_API_TOKEN": "your-access-token",
        "AUGMENT_API_URL": "your-tenant-url"
      }
    }
  }
}
```

Replace `your-access-token` and `your-tenant-url` with the values from step 1.


# Quickstart (Zed)
Source: https://docs.augmentcode.com/context-services/mcp/quickstart-zed

Get started with Augment Context Engine MCP in Zed in minutes

## Quick Start with Zed

### 1. Install Auggie CLI

```bash theme={null}
npm install -g @augmentcode/auggie@latest
```

### 2. Sign in to Augment

```bash theme={null}
auggie login
```

This will open a browser window for authentication.

### 3. Get your authentication token (Only if you set it up remotely, this is not mandatory locally.)

```bash theme={null}
auggie token print
```

This will output something like:

```
TOKEN={"accessToken":"your-access-token","tenantURL":"your-tenant-url","scopes":["read","write"]}
```

Copy the `accessToken` value (the long string after `"accessToken":"`) and the `tenantURL` value for the next step.

### 4. Configure the MCP server in Zed

* Click the ... then **Add Custom Server**
  <img alt="Zed custom server" />
* Paste the config below
  <img alt="Zed MCP" />

```json theme={null}
{
  "Augment-Context-Engine": {
    "enabled": true,
    "command": "auggie",
    "args": ["--mcp", "--mcp-auto-workspace"],
    "env": {}
  }
}
```

### 5. Test the integration

Prompt: "What is this project? Please use codebase retrieval tool to get the answer."

Zed should confirm it has access to the `codebase-retrieval` tool.

<img alt="Zed test" />


# Overview
Source: https://docs.augmentcode.com/context-services/overview

Context Services provide context for agents and apps

## What Are Context Services?

Context Services provide high-quality semantic search to AI agents and applications. Whether you're building custom agents or integrating with existing AI tools, Context Services give you access to Augment's world-class context engine.

<CardGroup>
  <Card title="Context Engine MCP" icon="plug" href="/context-services/mcp/overview">
    Plug Context Engine into any agent via the Model Context Protocol
  </Card>

  <Card title="Context Engine SDK" icon="code" href="/context-services/sdk/overview">
    Build context-aware custom agents or apps using our TypeScript or Python SDK
  </Card>
</CardGroup>

### Context Engine MCP

Plug Context Engine into any agent, such as Claude Code, Codex, Gemini CLI, and more via the Model Context Protocol (MCP).

**Perfect for:**

* Using Augment's context in your favorite AI tools
* Enriching any coding agent or AI with state-of-the-art codebase semantic search

[Get started with MCP →](/context-services/mcp/overview)

### Context Engine SDK

Build context-aware custom agents or apps using our TypeScript or Python SDK.

The SDK provides **FileSystem Context** to index local directories or **Direct Context** to index files from any source.

**Perfect for:**

* Building custom AI agents with codebase understanding
* Creating applications that need to understand codebase, documentation, specifications, runbooks, and other text sources
* Achieving state-of-the-art context quality in AI-powered code review, security scanning, failure analysis, migrations, and more ...

[Get started with the SDK →](/context-services/sdk/overview)


# API Reference
Source: https://docs.augmentcode.com/context-services/sdk/api-reference

Complete API documentation for the Context Engine SDK

<Warning>
  **Experimental API** - Context Engine SDK is experimental and subject to breaking changes.
</Warning>

## DirectContext

This class provides explicit file indexing via API calls with the ability to import and export state to avoid re-indexing between sessions.

***

## Examples

### Example 1: Simple Usage

Upload files and ask questions immediately:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { DirectContext } from '@augmentcode/auggie-sdk';

  async function simpleExample() {
    // Create context (authentication is automatic)
    const context = await DirectContext.create();

    // Add files and wait for indexing (default behavior)
    const result = await context.addToIndex([
      { path: 'src/auth.ts', contents: 'export function login(user, pass) { ... }' },
      { path: 'src/user.ts', contents: 'export class User { constructor(id) { ... } }' },
      { path: 'README.md', contents: '# My Project\nAuthentication system' }
    ]);

    console.log(`Newly uploaded: ${result.newlyUploaded.length}`);

    // Ask questions about the code - files are already indexed
    const answer = await context.searchAndAsk(
      'How does the login system work?'
    );
    console.log('Answer:', answer);
  }

  simpleExample().catch(console.error);
  ```

  ```python Python theme={null}
  from auggie_sdk.context import DirectContext, File

  def simple_example():
      # Create context (authentication is automatic)
      context = DirectContext.create()

      # Add files and wait for indexing (default behavior)
      result = context.add_to_index([
          File(path='src/auth.py', contents='def login(user, password): ...'),
          File(path='src/user.py', contents='class User:\n    def __init__(self, id): ...'),
          File(path='README.md', contents='# My Project\nAuthentication system')
      ])

      print(f"Newly uploaded: {len(result.newly_uploaded)}")

      # Ask questions about the code - files are already indexed
      answer = context.search_and_ask(
          'How does the login system work?'
      )
      print('Answer:', answer)

  if __name__ == '__main__':
      simple_example()
  ```
</CodeGroup>

### Example 2: Persistent Index

Persist state between sessions to avoid re-indexing. This is useful when you want to save the index state to disk and reload it later without having to re-upload and re-index all files. The saved state file contains metadata about which files are indexed, allowing you to resume from where you left off:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { DirectContext } from '@augmentcode/auggie-sdk';

  // First session: Upload and save
  async function uploadAndSave() {
    const context = await DirectContext.create();

    // Upload files
    await context.addToIndex([
      { path: 'src/auth.ts', contents: 'export function login() { ... }' },
      { path: 'src/user.ts', contents: 'export class User { ... }' },
      { path: 'src/database.ts', contents: 'export function connect() { ... }' }
    ]);

    // Save state for later use - this creates a JSON file containing the index metadata
    // so you can reload it later without re-indexing all files
    await context.exportToFile('./my-project-context.json');
    console.log('Context saved!');
    console.log('You can now reload this state in a future session using importFromFile()');
  }

  // Second session: Load, update incrementally, and save again
  async function updateAndSave() {
    // Load previous state - this restores the index without re-uploading files
    const context = await DirectContext.importFromFile('./my-project-context.json');
    console.log('Context loaded from previous session - no re-indexing needed!');

    // Make incremental changes - remove old file and add new one
    await context.removeFromIndex(['src/user.ts']);
    await context.addToIndex([
      { path: 'src/profile.ts', contents: 'export class Profile { /* profile logic */ }' },
      { path: 'src/settings.ts', contents: 'export function updateSettings() { /* settings */ }' }
    ]);
    console.log('Index updated incrementally');

    // Save updated state
    await context.exportToFile('./my-project-context.json');
    console.log('Updated context saved!');
  }

  // Third session: Load and search
  async function loadAndSearch() {
    // Load the updated state
    const context = await DirectContext.importFromFile('./my-project-context.json');
    console.log('Updated context loaded');

    // Search immediately - files are already indexed
    const answer = await context.searchAndAsk(
      'What user management features are implemented?'
    );
    console.log('Answer:', answer);
  }

  // Run the complete workflow: upload → update → search
  uploadAndSave()
    .then(() => updateAndSave())
    .then(() => loadAndSearch())
    .catch(console.error);
  ```

  ```python Python theme={null}
  from auggie_sdk.context import DirectContext, File

  # First session: Upload and save
  def upload_and_save():
      context = DirectContext.create()

      # Upload files
      context.add_to_index([
          File(path='src/auth.py', contents='def login(): ...'),
          File(path='src/user.py', contents='class User: ...'),
          File(path='src/database.py', contents='def connect(): ...')
      ])

      # Save state for later use - this creates a JSON file containing the index metadata
      # so you can reload it later without re-indexing all files
      context.export_to_file('./my-project-context.json')
      print('Context saved!')
      print('You can now reload this state in a future session using import_from_file()')

  # Second session: Load, update incrementally, and save again
  def update_and_save():
      # Load previous state - this restores the index without re-uploading files
      context = DirectContext.import_from_file('./my-project-context.json')
      print('Context loaded from previous session - no re-indexing needed!')

      # Make incremental changes - remove old file and add new one
      context.remove_from_index(['src/user.py'])
      context.add_to_index([
          File(path='src/profile.py', contents='class Profile: # profile logic'),
          File(path='src/settings.py', contents='def update_settings(): # settings')
      ])
      print('Index updated incrementally')

      # Save updated state
      context.export_to_file('./my-project-context.json')
      print('Updated context saved!')

  # Third session: Load and search
  def load_and_search():
      # Load the updated state
      context = DirectContext.import_from_file('./my-project-context.json')
      print('Updated context loaded')

      # Search immediately - files are already indexed
      answer = context.search_and_ask(
          'What user management features are implemented?'
      )
      print('Answer:', answer)

  # Run the complete workflow: upload → update → search
  if __name__ == '__main__':
      upload_and_save()
      update_and_save()
      load_and_search()
  ```
</CodeGroup>

### Example 3: Batch Upload Then Wait

When you need to upload many files in multiple batches, you can optimize performance by uploading all files first without waiting for indexing, then waiting once at the end. This approach is faster than waiting for indexing after each batch:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { DirectContext } from '@augmentcode/auggie-sdk';

  async function batchExample() {
    const context = await DirectContext.create();

    // Upload multiple batches without waiting for indexing
    await context.addToIndex([
      { path: 'src/auth.ts', contents: 'export function login() { ... }' },
      { path: 'src/user.ts', contents: 'export class User { ... }' }
    ], { waitForIndexing: false });

    await context.addToIndex([
      { path: 'src/database.ts', contents: 'export function connect() { ... }' },
      { path: 'src/api.ts', contents: 'export function createServer() { ... }' }
    ], { waitForIndexing: false });

    // Wait for all files to be indexed
    console.log('Waiting for indexing to complete...');
    await context.waitForIndexing();
    console.log('All files indexed!');

    // Now search - all files are guaranteed to be indexed
    const answer = await context.searchAndAsk(
      'How do the database and auth systems work together?'
    );
    console.log('Answer:', answer);
  }

  batchExample().catch(console.error);
  ```

  ```python Python theme={null}
  from auggie_sdk.context import DirectContext, File

  def batch_example():
      context = DirectContext.create()

      # Upload multiple batches without waiting for indexing
      context.add_to_index([
          File(path='src/auth.py', contents='def login(): ...'),
          File(path='src/user.py', contents='class User: ...')
      ], wait_for_indexing=False)

      context.add_to_index([
          File(path='src/database.py', contents='def connect(): ...'),
          File(path='src/api.py', contents='def create_server(): ...')
      ], wait_for_indexing=False)

      # Wait for all files to be indexed
      print('Waiting for indexing to complete...')
      context.wait_for_indexing()
      print('All files indexed!')

      # Now search - all files are guaranteed to be indexed
      answer = context.search_and_ask(
          'How do the database and auth systems work together?'
      )
      print('Answer:', answer)

  if __name__ == '__main__':
      batch_example()
  ```
</CodeGroup>

### Example 4: Custom Prompts

Use searchAndAsk with custom prompts for diverse tasks:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { DirectContext } from '@augmentcode/auggie-sdk';

  async function creativeExample() {
    const context = await DirectContext.create();

    // Upload some code
    await context.addToIndex([
      { path: 'src/auth.ts', contents: 'export function login(user, pass) { /* auth logic */ }' },
      { path: 'src/database.ts', contents: 'export function connect() { /* db connection */ }' },
      { path: 'README.md', contents: '# My App\nA secure authentication system' }
    ]);

    // Creative prompts with searchAndAsk
    const poem = await context.searchAndAsk(
      'authentication system',
      'Write a haiku about this authentication code'
    );
    console.log('Haiku:', poem);

    // Generate documentation
    const docs = await context.searchAndAsk(
      'database authentication flow',
      'Write a brief user guide explaining how to use the database authentication flow'
    );
    console.log('Documentation:', docs);

    // Code review style analysis
    const review = await context.searchAndAsk(
      'authentication logic',
      'Provide a code review focusing on security best practices'
    );
    console.log('Code Review:', review);
  }

  creativeExample().catch(console.error);
  ```

  ```python Python theme={null}
  from auggie_sdk.context import DirectContext, File

  def creative_example():
      context = DirectContext.create()

      # Upload some code
      context.add_to_index([
          File(path='src/auth.py', contents='def login(user, password): # auth logic'),
          File(path='src/database.py', contents='def connect(): # db connection'),
          File(path='README.md', contents='# My App\nA secure authentication system')
      ])

      # Creative prompts with search_and_ask
      poem = context.search_and_ask(
          'authentication system',
          'Write a haiku about this authentication code'
      )
      print('Haiku:', poem)

      # Generate documentation
      docs = context.search_and_ask(
          'database authentication flow',
          'Write a brief user guide explaining how to use the database authentication flow'
      )
      print('Documentation:', docs)

      # Code review style analysis
      review = context.search_and_ask(
          'authentication logic',
          'Provide a code review focusing on security best practices'
      )
      print('Code Review:', review)

  if __name__ == '__main__':
      creative_example()
  ```
</CodeGroup>

### Example 5: External LLM Integration

Use search() results with external LLM APIs:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { DirectContext } from '@augmentcode/auggie-sdk';
  // import { Anthropic } from '@anthropic-ai/sdk';
  // import OpenAI from 'openai';

  async function externalLLMExample() {
    const context = await DirectContext.create();

    // Upload code
    await context.addToIndex([
      { path: 'src/api.ts', contents: 'export function handleRequest() { /* API logic */ }' },
      { path: 'src/auth.ts', contents: 'export function authenticate() { /* auth */ }' },
      { path: 'src/database.ts', contents: 'export function query() { /* db query */ }' }
    ]);

    // Get formatted search results for external LLMs
    const codeContext = await context.search('API request handling');

    // codeContext is a formatted string ready to embed in prompts for
    // Anthropic, OpenAI, or other LLM APIs
    console.log('Code context for LLM:', codeContext);

    // Example: Use with Anthropic Claude (uncomment to use)
    // const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
    // const response = await anthropic.messages.create({
    //   model: 'claude-sonnet-4-5-20250929',
    //   max_tokens: 1000,
    //   messages: [{
    //     role: 'user',
    //     content: `Based on this code:\n\n${codeContext}\n\nHow can I improve the error handling in the API?`
    //   }]
    // });
    // console.log('Claude response:', response.content[0].text);

    // Example: Use with OpenAI GPT-5.1 (uncomment to use)
    // const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
    // const completion = await openai.chat.completions.create({
    //   model: 'gpt-5.1',
    //   messages: [{
    //     role: 'user',
    //     content: `Based on this code:\n\n${codeContext}\n\nSuggest performance optimizations for this API.`
    //   }]
    // });
    // console.log('GPT-5.1 response:', completion.choices[0].message.content);


  }

  externalLLMExample().catch(console.error);
  ```

  ```python Python theme={null}
  from auggie_sdk.context import DirectContext, File
  # import anthropic
  # import openai

  def external_llm_example():
      context = DirectContext.create()

      # Upload code
      context.add_to_index([
          File(path='src/api.py', contents='def handle_request(): # API logic'),
          File(path='src/auth.py', contents='def authenticate(): # auth'),
          File(path='src/database.py', contents='def query(): # db query')
      ])

      # Get formatted search results for external LLMs
      code_context = context.search('API request handling')

      # code_context is a formatted string ready to embed in prompts for
      # Anthropic, OpenAI, or other LLM APIs
      print('Code context for LLM:', code_context)

      # Example: Use with Anthropic Claude (uncomment to use)
      # client = anthropic.Anthropic(api_key=os.environ['ANTHROPIC_API_KEY'])
      # response = client.messages.create(
      #     model='claude-sonnet-4-5-20250929',
      #     max_tokens=1000,
      #     messages=[{
      #         'role': 'user',
      #         'content': f'Based on this code:\n\n{code_context}\n\nHow can I improve the error handling?'
      #     }]
      # )
      # print('Claude response:', response.content[0].text)

      # Example: Use with OpenAI GPT-5.1 (uncomment to use)
      # client = openai.OpenAI(api_key=os.environ['OPENAI_API_KEY'])
      # completion = client.chat.completions.create(
      #     model='gpt-5.1',
      #     messages=[{
      #         'role': 'user',
      #         'content': f'Based on this code:\n\n{code_context}\n\nSuggest performance optimizations.'
      #     }]
      # )
      # print('GPT-5.1 response:', completion.choices[0].message.content)

  if __name__ == '__main__':
      external_llm_example()
  ```
</CodeGroup>

***

## API Reference

### DirectContext.create()

Create and initialize a new DirectContext instance.

<CodeGroup>
  ```typescript TypeScript theme={null}
  static async create(options?: DirectContextOptions): Promise<DirectContext>

  interface DirectContextOptions {
    apiKey?: string;      // Optional - falls back to env vars or session.json
    apiUrl?: string;      // Optional - falls back to env vars or session.json
    debug?: boolean;      // Enable debug logging (default: false)
  }
  ```

  ```python Python theme={null}
  @classmethod
  def create(
      cls,
      *,
      api_key: Optional[str] = None,
      api_url: Optional[str] = None,
      debug: bool = False,
  ) -> DirectContext
  ```
</CodeGroup>

**Parameters:**

* `options` - Optional configuration object
  * `apiKey` - API key for authentication (optional)
  * `apiUrl` - API URL for your tenant (optional)
  * `debug` - Enable debug logging (optional, default: false)

**Authentication Priority:**

1. `options.apiKey` / `options.apiUrl` (passed to create())
2. `AUGMENT_API_TOKEN` / `AUGMENT_API_URL` environment variables
3. `~/.augment/session.json` (created by `auggie login`)

**Usage:** See complete examples above for full implementation details.

**Notes:**

* The SDK is **source-agnostic** - you provide files as `{path, contents}` objects
* Files larger than 1MB are rejected during indexing
* All indexing operations are serialized to ensure consistency
* State can be saved and loaded to avoid re-indexing

***

### DirectContext.importFromFile() / import\_from\_file()

Create a DirectContext instance from a saved state file.

<CodeGroup>
  ```typescript TypeScript theme={null}
  static async importFromFile(
    filePath: string,
    options?: DirectContextOptions
  ): Promise<DirectContext>
  ```

  ```python Python theme={null}
  @classmethod
  def import_from_file(
      cls,
      file_path: str,
      *,
      api_key: Optional[str] = None,
      api_url: Optional[str] = None,
      debug: bool = False,
  ) -> DirectContext
  ```
</CodeGroup>

**Parameters:**

* `filePath` / `file_path` - Path to the saved state file
* `options` - Optional configuration object (same as `create()`)

**Returns:** A DirectContext instance with restored state

**Usage:**

<CodeGroup>
  ```typescript TypeScript theme={null}
  // Load context from saved state
  const context = await DirectContext.importFromFile('./my-context.json');
  // Files are already indexed, ready to search
  ```

  ```python Python theme={null}
  # Load context from saved state
  context = DirectContext.import_from_file('./my-context.json')
  # Files are already indexed, ready to search
  ```
</CodeGroup>

***

### DirectContext.import() / import\_state()

Create a DirectContext instance from a saved state object.

<CodeGroup>
  ```typescript TypeScript theme={null}
  static async import(
    state: DirectContextState,
    options?: DirectContextOptions
  ): Promise<DirectContext>
  ```

  ```python Python theme={null}
  @classmethod
  def import_state(
      cls,
      state: DirectContextState,
      *,
      api_key: Optional[str] = None,
      api_url: Optional[str] = None,
      debug: bool = False,
  ) -> DirectContext
  ```
</CodeGroup>

**Parameters:**

* `state` - The state object to restore from
* `options` - Optional configuration object (same as `create()`)

**Returns:** A DirectContext instance with restored state

**Usage:**

<CodeGroup>
  ```typescript TypeScript theme={null}
  // Load context from state object
  const savedState = JSON.parse(stateJson);
  const context = await DirectContext.import(savedState);
  ```

  ```python Python theme={null}
  import json
  # Load context from state object
  with open('state.json') as f:
      saved_state = DirectContextState.from_dict(json.load(f))
  context = DirectContext.import_state(saved_state)
  ```
</CodeGroup>

***

## DirectContext Methods

### addToIndex() / add\_to\_index()

Add files to the index. Files can come from any source - memory, disk, API, database, etc.

<CodeGroup>
  ```typescript TypeScript theme={null}
  async addToIndex(
    files: File[],
    options?: { waitForIndexing?: boolean }
  ): Promise<IndexingResult>

  interface File {
    path: string;      // Relative path (e.g., "src/main.ts")
    contents: string;  // File contents as string
  }

  interface IndexingResult {
    newlyUploaded: string[];     // Paths that were uploaded and indexed
    alreadyUploaded: string[];   // Paths that were skipped (already on server)
  }
  ```

  ```python Python theme={null}
  def add_to_index(
      self,
      files: List[File],
      wait_for_indexing: bool = True
  ) -> IndexingResult

  @dataclass
  class File:
      path: str       # Relative path (e.g., "src/main.py")
      contents: str   # File contents as string

  @dataclass
  class IndexingResult:
      newly_uploaded: List[str]     # Paths that were uploaded and indexed
      already_uploaded: List[str]   # Paths that were skipped (already on server)
  ```
</CodeGroup>

**Parameters:**

* `files` - Array/list of file objects with `path` and `contents`
* `options` / `wait_for_indexing` - Optional configuration
  * `waitForIndexing` / `wait_for_indexing` - If true (default), waits for the newly added files to be indexed before returning

**Returns:** `IndexingResult` object with details about what was indexed

**Notes:**

* Files larger than 1MB will throw an error
* By default, waits for backend indexing to complete before returning (set `waitForIndexing: false` / `wait_for_indexing=False` to return immediately after upload)
* If a file with the same path already exists, it will be updated
* All operations are serialized to ensure consistency
* The SDK optimizes uploads by checking which blobs the server already has and only uploading missing ones

***

### removeFromIndex() / remove\_from\_index()

Remove files from the index by path.

<CodeGroup>
  ```typescript TypeScript theme={null}
  async removeFromIndex(paths: string[]): Promise<void>
  ```

  ```python Python theme={null}
  def remove_from_index(self, paths: List[str]) -> None
  ```
</CodeGroup>

**Parameters:**

* `paths` - Array/list of file paths to remove

***

### clearIndex() / clear\_index()

Clear the entire index, removing all files.

<CodeGroup>
  ```typescript TypeScript theme={null}
  async clearIndex(): Promise<void>
  ```

  ```python Python theme={null}
  def clear_index(self) -> None
  ```
</CodeGroup>

***

### getIndexedPaths() / get\_indexed\_paths()

Get the list of currently indexed file paths.

<CodeGroup>
  ```typescript TypeScript theme={null}
  getIndexedPaths(): string[]
  ```

  ```python Python theme={null}
  def get_indexed_paths(self) -> List[str]
  ```
</CodeGroup>

**Returns:** Array/list of relative file paths that are currently indexed

**Use Cases:**

* Display indexed files to users
* Verify which files are included in the index
* Filter files for targeted searches

***

### search()

Search the codebase and return formatted results as a string.

<CodeGroup>
  ```typescript TypeScript theme={null}
  async search(
    query: string,
    options?: { maxOutputLength?: number }
  ): Promise<string>
  ```

  ```python Python theme={null}
  def search(
      self,
      query: str,
      max_output_length: Optional[int] = None
  ) -> str
  ```
</CodeGroup>

**Parameters:**

* `query` - Natural language search query
* `options` / `max_output_length` - Optional search options
  * `maxOutputLength` / `max_output_length` - Maximum character length of the formatted output (default: 20000, max: 80000)

**Returns:** Formatted string containing the search results, ready for LLM consumption

**Notes:**

* Returns a formatted string designed for use in LLM prompts
* The format includes file paths, line numbers, and code content
* Does NOT wait for indexing - ensure files are indexed before searching by either:
  * Using `addToIndex()` / `add_to_index()` with `waitForIndexing: true` / `wait_for_indexing=True` (default)
  * Calling `waitForIndexing()` / `wait_for_indexing()` explicitly before searching
* Throws an error if the index is empty

***

### searchAndAsk() / search\_and\_ask()

Search the indexed codebase and ask an LLM a question about the results.

This is a convenience method that combines `search()` with an LLM call to answer questions about your codebase.

<CodeGroup>
  ```typescript TypeScript theme={null}
  async searchAndAsk(
    searchQuery: string,
    prompt?: string
  ): Promise<string>
  ```

  ```python Python theme={null}
  def search_and_ask(
      self,
      search_query: str,
      prompt: Optional[str] = None
  ) -> str
  ```
</CodeGroup>

**Parameters:**

* `searchQuery` / `search_query` - The semantic search query to find relevant code (also used as the prompt if no separate prompt is provided)
* `prompt` - Optional prompt to ask the LLM about the search results. If not provided, searchQuery is used as the prompt.

**Returns:** The LLM's answer to your question

**Notes:**

* Does NOT wait for indexing - ensure files are indexed before searching by either:
  * Using `addToIndex()` / `add_to_index()` with `waitForIndexing: true` / `wait_for_indexing=True` (default)
  * Calling `waitForIndexing()` / `wait_for_indexing()` explicitly before searching
* Requires `AUGMENT_API_TOKEN` and `AUGMENT_API_URL` environment variables for LLM access

**Use Cases:**

* Quick Q\&A about your codebase
* Building conversational interfaces
* Automated code analysis and documentation

***

### waitForIndexing() / wait\_for\_indexing()

Wait for all indexed files to be fully indexed on the backend.

This method polls the backend until all files that have been added to the index are confirmed to be indexed and searchable.

<CodeGroup>
  ```typescript TypeScript theme={null}
  async waitForIndexing(): Promise<void>
  ```

  ```python Python theme={null}
  def wait_for_indexing(self) -> None
  ```
</CodeGroup>

**Returns:** Promise that resolves when all files are indexed

**Notes:**

* Throws an error if indexing times out (default: 10 minutes)
* Only waits for files that have been added to the index
* Useful when you want to control when to wait for indexing completion

**Use Cases:**

* Batch upload multiple files quickly, then wait for all to be indexed
* Ensure search results include all recently added files
* Control timing of indexing waits in complex workflows

***

### exportToFile() / export\_to\_file()

Export the current state to a file.

<CodeGroup>
  ```typescript TypeScript theme={null}
  async exportToFile(filePath: string): Promise<void>
  ```

  ```python Python theme={null}
  def export_to_file(self, file_path: str) -> None
  ```
</CodeGroup>

**Parameters:**

* `filePath` / `file_path` - Path to save the state file

**Use Cases:**

* Persist indexing state between sessions
* Avoid re-indexing large codebases
* Share indexing state across different processes

***

### export()

Export the current state as an object (in-memory).

<CodeGroup>
  ```typescript TypeScript theme={null}
  export(): DirectContextState

  interface DirectContextState {
    checkpointId?: string;
    addedBlobs: string[];
    deletedBlobs: string[];
    blobs: BlobEntry[];  // Array of [blobName, path] tuples
  }
  ```

  ```python Python theme={null}
  def export(self) -> DirectContextState

  @dataclass
  class DirectContextState:
      checkpoint_id: Optional[str]
      added_blobs: List[str]
      deleted_blobs: List[str]
      blobs: List[Tuple[str, str]]  # List of (blob_name, path) tuples
  ```
</CodeGroup>

**Returns:** State object that can be serialized and stored

***

## FileSystemContext

This class provides automatic indexing and search capabilities for a local directory.

### FileSystemContext.create()

Create and initialize a new FileSystemContext instance.

<CodeGroup>
  ```typescript TypeScript theme={null}
  static async create(options: FileSystemContextOptions): Promise<FileSystemContext>

  interface FileSystemContextOptions {
    directory: string;      // Path to the workspace directory to index
    auggiePath?: string;    // Path to auggie executable (default: "auggie")
    debug?: boolean;        // Enable debug logging (default: false)
  }
  ```

  ```python Python theme={null}
  @classmethod
  def create(
      cls,
      directory: str,
      *,
      auggie_path: str = "auggie",
      debug: bool = False,
  ) -> FileSystemContext
  ```
</CodeGroup>

**Parameters:**

* `options` / positional args - Configuration
  * `directory` - Path to the workspace directory to index (required)
  * `auggiePath` / `auggie_path` - Path to auggie executable (optional, default: "auggie")
  * `debug` - Enable debug logging (optional, default: false)

**Usage:** See DirectContext examples above for similar patterns.

**Notes:**

* Automatically indexes the directory on startup
* Requires `auggie` CLI to be installed and accessible
* Python supports context manager (`with` statement) for automatic cleanup

***

## FileSystemContext Methods

### search()

Search the codebase and return formatted results as a string.

<CodeGroup>
  ```typescript TypeScript theme={null}
  async search(query: string): Promise<string>
  ```

  ```python Python theme={null}
  def search(self, query: str) -> str
  ```
</CodeGroup>

**Parameters:**

* `query` - Natural language search query

**Returns:** Formatted string containing the search results, ready for LLM consumption

***

### searchAndAsk() / search\_and\_ask()

Search the indexed codebase and ask an LLM a question about the results.

<CodeGroup>
  ```typescript TypeScript theme={null}
  async searchAndAsk(
    searchQuery: string,
    prompt?: string
  ): Promise<string>
  ```

  ```python Python theme={null}
  def search_and_ask(
      self,
      search_query: str,
      prompt: Optional[str] = None
  ) -> str
  ```
</CodeGroup>

**Parameters:**

* `searchQuery` / `search_query` - The semantic search query to find relevant code (also used as the prompt if no separate prompt is provided)
* `prompt` - Optional prompt to ask the LLM about the search results. If not provided, searchQuery is used as the prompt.

**Returns:** The LLM's answer to your question

**Notes:**

* Requires `AUGMENT_API_TOKEN` and `AUGMENT_API_URL` environment variables for LLM access

***

### close()

Close the connection and cleanup resources.

<CodeGroup>
  ```typescript TypeScript theme={null}
  async close(): Promise<void>
  ```

  ```python Python theme={null}
  def close(self) -> None
  ```
</CodeGroup>

**Notes:**

* Always call `close()` when done to cleanup resources
* Python: Use context manager (`with` statement) for automatic cleanup

***

## Types

### File

Represents a file to be indexed (input type for `addToIndex()` / `add_to_index()`).

<CodeGroup>
  ```typescript TypeScript theme={null}
  interface File {
    path: string;      // Relative path (e.g., "src/main.ts")
    contents: string;  // File contents as string
  }
  ```

  ```python Python theme={null}
  @dataclass
  class File:
      path: str       # Relative path (e.g., "src/main.py")
      contents: str   # File contents as string
  ```
</CodeGroup>

### IndexingResult

Result from `addToIndex()` / `add_to_index()` operation showing what was indexed.

<CodeGroup>
  ```typescript TypeScript theme={null}
  interface IndexingResult {
    newlyUploaded: string[];     // Paths that were uploaded and indexed
    alreadyUploaded: string[];   // Paths that were skipped (already on server)
  }
  ```

  ```python Python theme={null}
  @dataclass
  class IndexingResult:
      newly_uploaded: List[str]     # Paths that were uploaded and indexed
      already_uploaded: List[str]   # Paths that were skipped (already on server)
  ```
</CodeGroup>

**Notes:**

* `newlyUploaded` / `newly_uploaded`: Files that were uploaded to the server and indexed
* `alreadyUploaded` / `already_uploaded`: Files that were skipped because:
  * They were already in the local cache with the same content, OR
  * The server already had the blob (detected via `find-missing` API)

### DirectContextOptions (TypeScript) / Keyword Arguments (Python)

Options for configuring DirectContext.

<CodeGroup>
  ```typescript TypeScript theme={null}
  interface DirectContextOptions {
    apiKey?: string;      // API key for authentication
    apiUrl?: string;      // API URL for your Augment tenant
    debug?: boolean;      // Enable debug logging (default: false)
  }
  ```

  ```python Python theme={null}
  # In Python, these are passed as keyword arguments to create():
  DirectContext.create(
      api_key: Optional[str] = None,  # API key for authentication
      api_url: Optional[str] = None,  # API URL for your Augment tenant
      debug: bool = False,            # Enable debug logging (default: False)
  )
  ```
</CodeGroup>

### DirectContextState

State for DirectContext that can be saved/loaded.

<CodeGroup>
  ```typescript TypeScript theme={null}
  interface DirectContextState {
    checkpointId?: string;      // Current checkpoint ID
    addedBlobs: string[];       // Blob names added (pending checkpoint)
    deletedBlobs: string[];     // Blob names deleted (pending checkpoint)
    blobs: BlobEntry[];         // List of blobs as [blobName, path] tuples
  }

  type BlobEntry = [blobName: string, path: string];
  ```

  ```python Python theme={null}
  @dataclass
  class DirectContextState:
      checkpoint_id: Optional[str]       # Current checkpoint ID
      added_blobs: List[str]             # Blob names added (pending checkpoint)
      deleted_blobs: List[str]           # Blob names deleted (pending checkpoint)
      blobs: List[Tuple[str, str]]       # List of (blob_name, path) tuples

      def to_dict(self) -> Dict[str, Any]:
          """Convert to JSON-serializable dict."""
          ...

      @classmethod
      def from_dict(cls, data: Dict[str, Any]) -> DirectContextState:
          """Create from JSON dict (e.g., from imported state file)."""
          ...
  ```
</CodeGroup>

**Serialization Example:**

<CodeGroup>
  ```typescript TypeScript theme={null}
  // DirectContextState is a plain object, use JSON.parse/stringify
  const stateJson = JSON.stringify(context.export());
  const restoredState = JSON.parse(stateJson);
  const newContext = await DirectContext.import(restoredState);
  ```

  ```python Python theme={null}
  import json

  # Export state and serialize to JSON
  state = context.export()
  state_json = json.dumps(state.to_dict())

  # Later: deserialize and import
  data = json.loads(state_json)
  restored_state = DirectContextState.from_dict(data)
  new_context = DirectContext.import_state(restored_state)
  ```
</CodeGroup>

### FileSystemContextOptions (TypeScript) / Keyword Arguments (Python)

Options for FileSystem Context.

<CodeGroup>
  ```typescript TypeScript theme={null}
  interface FileSystemContextOptions {
    directory: string;      // Path to the workspace directory to index
    auggiePath?: string;    // Path to auggie executable (default: "auggie")
    debug?: boolean;        // Enable debug logging (default: false)
  }
  ```

  ```python Python theme={null}
  # In Python, these are passed as arguments to create():
  FileSystemContext.create(
      directory: str,                    # Path to the workspace directory to index
      auggie_path: str = "auggie",       # Path to auggie executable (default: "auggie")
      debug: bool = False,               # Enable debug logging (default: False)
  )
  ```
</CodeGroup>

***

## Authentication

The SDK automatically loads credentials from multiple sources in this priority order:

1. **Options/keyword arguments**: `apiKey`/`api_key` and `apiUrl`/`api_url` passed to `DirectContext.create()`
2. **Environment variables**: `AUGMENT_API_TOKEN` and `AUGMENT_API_URL`
3. **Session file**: `~/.augment/session.json` (created by `auggie login`)

**To get credentials:**

1. Sign in to Augment using the CLI: `auggie login`
2. Your credentials will be stored in `~/.augment/session.json`
3. The SDK will automatically use them

***

## Error Handling

The SDK exports specific error classes for better error handling:

| Error Class         | Description                                                    |
| ------------------- | -------------------------------------------------------------- |
| `BlobTooLargeError` | File exceeds 1MB limit. Includes `path` and `size` properties. |
| `APIError`          | Network or API request failures. Includes `status` property.   |

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { DirectContext, APIError, BlobTooLargeError } from '@augmentcode/auggie-sdk';

  try {
    const context = await DirectContext.create();
    await context.addToIndex([
      { path: 'test.ts', contents: '...' }
    ]);
    const results = await context.search('query');
  } catch (error) {
    if (error instanceof BlobTooLargeError) {
      console.error('File too large (max 1MB):', error.path);
    } else if (error instanceof APIError) {
      console.error('API request failed:', error.message);
      console.error('Status code:', error.status);
    } else if (error.message.includes('API key is required')) {
      console.error('Missing credentials');
    } else if (error.message.includes('Index not initialized')) {
      console.error('No files indexed yet');
    } else {
      console.error('Operation failed:', error);
    }
  }
  ```

  ```python Python theme={null}
  from auggie_sdk.context import DirectContext, File, APIError, BlobTooLargeError

  try:
      context = DirectContext.create()
      context.add_to_index([
          File(path='test.py', contents='...')
      ])
      results = context.search('query')
  except BlobTooLargeError as error:
      print('File too large (max 1MB):', error)
  except APIError as error:
      print('API request failed:', error)
  except ValueError as error:
      if 'API key is required' in str(error):
          print('Missing credentials')
      elif 'Index not initialized' in str(error):
          print('No files indexed yet')
      else:
          print('Operation failed:', error)
  except Exception as error:
      print('Operation failed:', error)
  ```
</CodeGroup>


# Examples
Source: https://docs.augmentcode.com/context-services/sdk/examples

Example applications using the Auggie SDK

<Warning>
  **Experimental API** - Context Engine SDK is experimental and subject to breaking changes.
</Warning>

## Available Examples

<CardGroup>
  <Card title="Direct Context" icon="code" href="#direct-context">
    API-based indexing and search
  </Card>

  <Card title="FileSystem Context" icon="folder" href="#filesystem-context">
    Local directory search
  </Card>

  <Card title="File Search Server" icon="server" href="#file-search-server">
    REST API for code search
  </Card>

  <Card title="Prompt Enhancer Server" icon="wand-magic-sparkles" href="#prompt-enhancer-server">
    Context-aware prompt enhancement
  </Card>

  <Card title="GitHub Action Indexer" icon="github" href="#github-action-indexer">
    CI/CD repository indexing
  </Card>
</CardGroup>

***

## Getting the Examples

All example code is available in the Auggie repository. To access the examples:

<CodeGroup>
  ```bash TypeScript theme={null}
  git clone https://github.com/augmentcode/auggie.git
  cd auggie/examples/typescript-sdk/context
  ```

  ```bash Python theme={null}
  git clone https://github.com/augmentcode/auggie.git
  cd auggie/examples/python-sdk/context
  ```
</CodeGroup>

Each example is a complete, runnable application demonstrating different use cases of the Auggie SDK.

## Prerequisites

Before running the examples:

1. **Runtime** - One of the following:
   * **TypeScript:** Node.js 18+
   * **Python:** Python 3.10+

2. **Auggie CLI** - Required for FileSystem Context examples
   ```bash theme={null}
   npm install -g @augmentcode/auggie@latest
   ```

3. **Authentication** - Required for all examples

   ```bash theme={null}
   auggie login
   ```

   This creates a session file at `~/.augment/session.json` with your API token.

   Alternatively, set environment variables:

   ```bash theme={null}
   export AUGMENT_API_TOKEN="your-api-token"
   export AUGMENT_API_URL="https://your-tenant.api.augmentcode.com"
   ```

## Setup

Install dependencies:

<CodeGroup>
  ```bash TypeScript theme={null}
  cd examples/typescript-sdk/context
  npm install
  ```

  ```bash Python theme={null}
  cd examples/python-sdk/context
  pip install auggie-sdk
  ```
</CodeGroup>

***

## Simple Examples

Get started quickly with these basic examples that demonstrate core SDK functionality.

### Direct Context

Demonstrates indexing files from any source and performing semantic searches with AI-powered question answering.

**Quick Start:**

<CodeGroup>
  ```bash TypeScript theme={null}
  npm run direct-context
  ```

  ```bash Python theme={null}
  python -m direct_context
  ```
</CodeGroup>

**Or run directly:**

<CodeGroup>
  ```bash TypeScript theme={null}
  npx tsx direct-context/index.ts
  ```

  ```bash Python theme={null}
  python direct_context/main.py
  ```
</CodeGroup>

***

### FileSystem Context

Shows how to search a local directory using automatic file discovery via the MCP protocol.

**Prerequisites:**

* Auggie CLI must be installed and in your PATH
* Authentication via `auggie login` or `AUGMENT_API_TOKEN` environment variable
* A `.gitignore` or `.augmentignore` file in the workspace directory to exclude `node_modules/` and other large directories

**Important:** The FileSystem Context indexes all files in the workspace directory. To avoid timeouts when indexing large directories (like `node_modules/`), make sure you have a `.gitignore` or `.augmentignore` file that excludes them.

**Quick Start:**

<CodeGroup>
  ```bash TypeScript theme={null}
  npm run filesystem-context
  ```

  ```bash Python theme={null}
  python -m filesystem_context
  ```
</CodeGroup>

**Or run directly:**

<CodeGroup>
  ```bash TypeScript theme={null}
  npx tsx filesystem-context/index.ts
  ```

  ```bash Python theme={null}
  python filesystem_context/main.py
  ```
</CodeGroup>

***

## Developer Tools

Build production-ready applications with these server examples.

### File Search Server

A REST API server that provides semantic file search with AI-powered summarization.

**Prerequisites:** Auggie CLI must be installed and in your PATH.

**Quick Start:**

<CodeGroup>
  ```bash TypeScript theme={null}
  npm run file-search-server [workspace-directory]
  ```

  ```bash Python theme={null}
  python -m file_search_server [workspace-directory]
  ```
</CodeGroup>

Then query the API:

```bash theme={null}
curl "http://localhost:3000/search?q=typescript"
```

**Or run directly:**

<CodeGroup>
  ```bash TypeScript theme={null}
  npx tsx file-search-server/index.ts .
  ```

  ```bash Python theme={null}
  python file_search_server/main.py .
  ```
</CodeGroup>

***

### Prompt Enhancer Server

An HTTP server that automatically enriches user prompts with relevant codebase context.

**Prerequisites:** Auggie CLI must be installed and in your PATH.

**Quick Start:**

<CodeGroup>
  ```bash TypeScript theme={null}
  npm run prompt-enhancer-server [workspace-directory]
  ```

  ```bash Python theme={null}
  python -m prompt_enhancer_server [workspace-directory]
  ```
</CodeGroup>

Then enhance prompts:

```bash theme={null}
curl -X POST http://localhost:3001/enhance \
  -H "Content-Type: application/json" \
  -d '{"prompt": "fix the login bug"}'
```

**Or run directly:**

<CodeGroup>
  ```bash TypeScript theme={null}
  npx tsx prompt-enhancer-server/index.ts .
  ```

  ```bash Python theme={null}
  python prompt_enhancer_server/main.py .
  ```
</CodeGroup>

***

## CI/CD Integration

Integrate the SDK into your continuous integration workflows.

### GitHub Action Indexer

Automatically index your GitHub repositories with **zero-question setup** and incremental updates. Perfect for CI/CD workflows and keeping your codebase searchable.

**Key Features:**

* 🔄 **Incremental indexing** - Only processes changed files for efficiency
* 💾 **Smart caching** - Persists index state between runs
* 🚀 **30-second setup** - From zero to running GitHub Action

**Installation:**

<CodeGroup>
  ```bash TypeScript theme={null}
  # Install directly into your repository
  cd /path/to/your/repository
  npx @augment-samples/github-action-indexer install

  # Add your API secrets to GitHub repository settings
  # Push to trigger automatic indexing on every commit
  ```

  ```bash Python theme={null}
  # From the auggie repo, install into your target repository
  cd examples/python-sdk/context
  python -m github_action_indexer install /path/to/your/repository

  # Add your API secrets to GitHub repository settings
  # Push to trigger automatic indexing on every commit
  ```
</CodeGroup>

**What It Does:**

1. **Indexes** your codebase automatically on every push
2. **Updates** incrementally using GitHub's Compare API
3. **Caches** index state for fast subsequent runs
4. **Handles** large repositories with optimized performance settings

**Perfect For:**

* Keeping your codebase searchable and up-to-date
* CI/CD workflows that need codebase understanding
* Teams wanting automatic repository indexing
* Projects with frequent commits (incremental updates are fast)

**Try It Locally First:**

<CodeGroup>
  ```bash TypeScript theme={null}
  cd github-action-indexer
  npm install
  export AUGMENT_API_TOKEN="your-token"
  export AUGMENT_API_URL="https://your-tenant.api.augmentcode.com/"
  export GITHUB_TOKEN="your-github-token"
  export GITHUB_REPOSITORY="owner/repo"
  export GITHUB_SHA="$(git rev-parse HEAD)"
  npm run index
  npm run search "authentication functions"
  ```

  ```bash Python theme={null}
  cd examples/python-sdk/context
  pip install -r github_action_indexer/augment_indexer/requirements.txt
  export AUGMENT_API_TOKEN="your-token"
  export AUGMENT_API_URL="https://your-tenant.api.augmentcode.com/"
  export GITHUB_TOKEN="your-github-token"
  export GITHUB_REPOSITORY="owner/repo"
  export GITHUB_SHA="$(git rev-parse HEAD)"
  python -m github_action_indexer index
  python -m github_action_indexer search "authentication functions"
  ```
</CodeGroup>

📖 **Complete Setup Guides:**

* [TypeScript GitHub Action Indexer →](https://github.com/augmentcode/auggie/tree/main/examples/typescript-sdk/context/github-action-indexer)
* [Python GitHub Action Indexer →](https://github.com/augmentcode/auggie/tree/main/examples/python-sdk/context/github_action_indexer)

***

## Troubleshooting

### MCP Timeout in FileSystem Context

**Problem:** The FileSystem Context example times out during indexing.

**Cause:** The workspace directory contains too many files (e.g., `node_modules/` with 45,000+ files).

**Solution:** Create a `.gitignore` or `.augmentignore` file in the workspace directory to exclude large directories:

```bash theme={null}
# .gitignore or .augmentignore
node_modules/
dist/
__pycache__/
.venv/
*.log
.DS_Store
```

The auggie CLI respects both `.gitignore` and `.augmentignore` patterns and will skip excluded files during indexing.

### Authentication Errors

**Problem:** `Error: API key is required for searchAndAsk()` or `ValueError: API credentials are required`

**Cause:** The SDK cannot find your authentication credentials.

**Solution:** Run `auggie login` to authenticate, or set the `AUGMENT_API_TOKEN` and `AUGMENT_API_URL` environment variables.

***

## Next Steps

<CardGroup>
  <Card title="API Reference" icon="code" href="/context-services/sdk/api-reference">
    Complete API documentation
  </Card>

  <Card title="Quick Start" icon="rocket" href="/context-services/sdk/overview">
    Back to quick start guide
  </Card>
</CardGroup>


# Quickstart
Source: https://docs.augmentcode.com/context-services/sdk/overview

Get started with the Augment Context Engine SDK in minutes

<Warning>
  **Experimental API** - Context Engine SDK is experimental and subject to breaking changes.
</Warning>

## Installation

<CodeGroup>
  ```bash TypeScript theme={null}
  npm install -g @augmentcode/auggie@latest && npm install @augmentcode/auggie-sdk
  ```

  ```bash Python theme={null}
  npm install -g @augmentcode/auggie@latest
  pip install auggie-sdk
  ```
</CodeGroup>

## Getting Credentials

Sign in to Augment using the CLI:

```bash theme={null}
auggie login
```

Your credentials will be stored in `~/.augment/session.json` and the SDK will automatically use them.

Alternatively, you can use environment variables:

```bash theme={null}
export AUGMENT_API_TOKEN="your-api-token"
export AUGMENT_API_URL="https://your-tenant.api.augmentcode.com"
```

<Note>
  **Finding your tenant URL:** After signing in with `auggie login`, run `auggie token print` to see your API token and tenant URL. The URL format is `https://[your-organization-name].api.augmentcode.com`.
</Note>

## Direct Context

Explicitly index files from any source (APIs, databases, memory, disk) with full control over what gets indexed and the ability to save/load state:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { DirectContext } from '@augmentcode/auggie-sdk';

  async function main() {
    // Authentication is automatic via:
    // 1. Options parameters (apiKey, apiUrl passed to create())
    // 2. Environment variables (AUGMENT_API_TOKEN, AUGMENT_API_URL)
    // 3. ~/.augment/session.json (created by `auggie login`)
    const context = await DirectContext.create();

    // Add files to index
    const result = await context.addToIndex([
      { path: 'src/main.ts', contents: 'export function main() { ... }' },
      { path: 'src/auth.ts', contents: 'export function authenticate() { ... }' }
    ]);

    console.log(`Newly uploaded: ${result.newlyUploaded.length}`);
    console.log(`Already uploaded: ${result.alreadyUploaded.length}`);

    // Search - returns formatted string ready for LLM use or display
    const results = await context.search('authentication logic');
    console.log(results);

    // Or use searchAndAsk for one-step Q&A
    const answer = await context.searchAndAsk(
      'How does authentication work?'
    );
    console.log(answer);

    // Save state to avoid re-indexing
    await context.exportToFile('/tmp/state.json');
  }

  main();
  ```

  ```python Python theme={null}
  from auggie_sdk.context import DirectContext, File

  def main():
      # Authentication is automatic via:
      # 1. Options parameters (api_key, api_url passed to create())
      # 2. Environment variables (AUGMENT_API_TOKEN, AUGMENT_API_URL)
      # 3. ~/.augment/session.json (created by `auggie login`)
      context = DirectContext.create()

      # Add files to index
      result = context.add_to_index([
          File(path='src/main.py', contents='def main(): ...'),
          File(path='src/auth.py', contents='def authenticate(): ...')
      ])

      print(f"Newly uploaded: {len(result.newly_uploaded)}")
      print(f"Already uploaded: {len(result.already_uploaded)}")

      # Search - returns formatted string ready for LLM use or display
      results = context.search('authentication logic')
      print(results)

      # Or use search_and_ask for one-step Q&A
      answer = context.search_and_ask(
          'How does authentication work?'
      )
      print(answer)

      # Save state to avoid re-indexing
      context.export_to_file('/tmp/state.json')

  if __name__ == '__main__':
      main()
  ```
</CodeGroup>

## FileSystem Context

Automatically index and search a local directory - just point to a directory path and start searching, perfect for local development and testing:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { FileSystemContext } from '@augmentcode/auggie-sdk';

  async function main() {
    const context = await FileSystemContext.create({
      directory: '/path/to/workspace',
    });

    // Search the directory
    const results = await context.search('authentication logic');
    console.log(results);

    // Or ask a question
    const answer = await context.searchAndAsk(
      'How does authentication work?'
    );
    console.log(answer);

    // Clean up
    await context.close();
  }

  main();
  ```

  ```python Python theme={null}
  from auggie_sdk.context import FileSystemContext

  def main():
      # Use context manager for automatic cleanup
      with FileSystemContext.create('/path/to/workspace') as context:
          # Search the directory
          results = context.search('authentication logic')
          print(results)

          # Or ask a question
          answer = context.search_and_ask(
              'How does authentication work?'
          )
          print(answer)

  if __name__ == '__main__':
      main()
  ```
</CodeGroup>

## Next Steps

<CardGroup>
  <Card title="Examples" icon="lightbulb" href="/context-services/sdk/examples">
    See more example applications
  </Card>

  <Card title="API Reference" icon="code" href="/context-services/sdk/api-reference">
    Explore the complete API
  </Card>
</CardGroup>


# Introduction
Source: https://docs.augmentcode.com/introduction

Augment is the developer AI platform that helps you understand code, debug issues, and ship faster because it understands your codebase. Use Agent, Next Edit, and Code Completions to get more done.

<img alt="Augment Code" />

## Get started in minutes

Augment works with your favorite IDE and your favorite programming language. Download the extension, sign in, and get coding.

<CardGroup>
  <Card href="/setup-augment/install-visual-studio-code">
    <img alt="Visual Studio Code" />

    <h2>
      Visual Studio Code
    </h2>

    <p>
      Get completions, chat, and instructions in your favorite open source
      editor.
    </p>
  </Card>

  <Card href="/setup-augment/install-jetbrains-ides">
    <img alt="JetBrains IDEs" />

    <h2>
      JetBrains IDEs
    </h2>

    <p>
      Completions are available for all JetBrains IDEs, like WebStorm, PyCharm,
      and IntelliJ.
    </p>
  </Card>

  <Card href="/cli/overview">
    <img alt="Auggie CLI" />

    <h2>
      Auggie CLI
    </h2>

    <p>
      All the power of Augment's agent, context engine, and tools in your terminal.
    </p>
  </Card>
</CardGroup>

## Learn more

Get up to speed, stay in the flow, and get more done. Chat, Next Edit, and Code Completions will change the way you build software.

<CardGroup>
  <Card title="Agent" icon={<AgentIcon />} href="/using-augment/agent">
    Autonomous coding with Augment's context engine and tools can tackle tasks big and small
  </Card>

  <Card title="Next Edit" icon={<NextEditIcon />} href="/using-augment/next-edit">
    Keep moving through your tasks by guiding you step-by-step through complex or repetitive changes.
  </Card>

  <Card title="Code Completions" icon={<CodeIcon />} href="/using-augment/completions">
    Intelligent code suggestions that knows your codebase right at your
    fingertips.
  </Card>
</CardGroup>


# Agent Integrations
Source: https://docs.augmentcode.com/jetbrains/setup-augment/agent-integrations

Configure integrations for Augment Agent to access external services like GitHub, Linear, Jira, Confluence, and Notion.

## About Agent Integrations

Augment Agent can access external services through integrations to add additional context to your requests and take actions on your behalf. These integrations allow Augment Agent to seamlessly work with your development tools without leaving your editor.

Once set up, Augment Agent will automatically use the appropriate integration based on your request context. Or, you can always mention the service in your request to use the integration.

## Setting Up Integrations

To set up integrations with Augment Agent in JetBrains IDEs, follow these steps:

1. Click the Augment icon in the bottom right of your IDE and select <Command />
2. Click "Connect" for the integration you want to set up

<img alt="Set up integrations in the settings page" />

You'll be redirected to authorize the integration with the appropriate service. After authorization, the integration will be available for use with Augment Agent.

## Easy MCP Integrations

> **New:** Easy MCP launched ONLY July 30, 2025, providing one-click access to popular developer tools.

Easy MCP transforms complex MCP server setup into a single click. Available integrations include:

* **CircleCI** - Build logs, test insights, and flaky-test detection
* **MongoDB** - Data exploration, database management, and context-aware code generation
* **Redis** - Keyspace introspection, TTL audits, and migration helpers

For detailed setup instructions and examples, see [Configure MCP servers](/jetbrains/setup-augment/mcp).

## Native Integrations

## <div><div><GitHubLogo /></div> GitHub Integration</div>

Add additional context to your requests and take actions. Pull in information from a GitHub Issue, make the changes to your code (or have Agent do it for you), and open a Pull Request all without leaving your editor.

### Examples

* "Implement Issue #123 and open up a pull request"
* "Find all issues assigned to me"
* "Check the CI status of my latest commit"

For authorization details, see [GitHub documentation](https://docs.github.com/en/apps/using-github-apps/installing-a-github-app-from-a-third-party).

## <div><div><LinearLogo /></div> Linear Integration</div>

Read, update, comment on, and resolve your Linear issues within your IDE.

### Examples

* "Fix TES-1"
* "Create Linear tickets for these TODOs"
* "Help me triage these new bug reports"

For authorization details, see [Linear documentation](https://linear.app/docs/third-party-application-approvals).

## <div><div><JiraLogo /></div> Jira Integration</div>

Work on your Jira issues, create new tickets, and update existing ones.

### Examples

* "Show me all my assigned Jira tickets"
* "Create a Jira ticket for this bug"
* "Create a PR to fix SOF-123"
* "Update the status of PROJ-123 to 'In Progress'"

For authorization details, see [Jira documentation](https://support.atlassian.com/jira-software-cloud/docs/allow-oauth-access/).

## <div><div><ConfluenceLogo /></div> Confluence Integration</div>

Query existing documentation or update pages directly from your IDE. Ensure your team's knowledge base stays current without any context switching.

### Examples

* "Summarize our Confluence page on microservice architecture"
* "Find information about our release process in Confluence"
* "Update our onboarding docs to explain how we use Bazel"

For authorization details, see [Confluence documentation](https://developer.atlassian.com/cloud/confluence/oauth-2-3lo-apps/).

## <div><div><NotionLogo /></div> Notion Integration</div>

Search and retrieve information from your team's knowledge base - access documentation, meeting notes, and project specifications. This integration is currently READ-ONLY.

### Examples

* "Find Notion pages about our API documentation"
* "Show me the technical specs for the payment system"
* "What outstanding tasks are left from yesterday's team meeting?"

For authorization details, see [Notion documentation](https://www.notion.so/help/add-and-manage-connections-with-the-api#install-from-a-developer).

## <div><div><GleanLogo /></div> Glean Integration</div>

> **Note:** The Glean integration is in early access and thus is a little different from other integrations.
>
> * It is currently only available to enterprise customers.
> * It does not appear in the list of integrations in the settings panel.

The Glean integration lets the agent retrieve information from your team's internal data sources leveraging Glean's powerful search engine.

**To Enable the Glean Integration:** You'll need to be have administrator access to Augment and Glean. Follow the instructions on [https://app.augmentcode.com/gleanConfig](https://app.augmentcode.com/gleanConfig) and your agent will be ready to use Glean!

### Examples

* "Search Glean for past related incidents and how they were resolved"
* "Search Glean for why we're migrating to a new payment processor"

## Next Steps

* [Configure additional tools with Easy MCP or advanced MCP setup](/jetbrains/setup-augment/mcp)
* Explore one-click integrations for CircleCI, MongoDB, and Redis through Easy MCP


# Install Augment for JetBrains IDEs
Source: https://docs.augmentcode.com/jetbrains/setup-augment/install-jetbrains-ides

Are you ready for your new superpowers? Augment in JetBrains IDEs gives you powerful code completions integrated into your favorite text editor.

<Info>
  Augment requires version `2024.3` or above for all JetBrains IDEs. [See
  JetBrains documentation](https://www.jetbrains.com/help/) on how to update
  your IDE.
</Info>

<CardGroup>
  <Card title="Get the Augment Plugin" href="https://plugins.jetbrains.com/plugin/24072-augment" icon={<JetbrainsLogo />}>
    Install Augment for JetBrains IDEs
  </Card>
</CardGroup>

## About Installation

Installing <ExternalLink href="https://plugins.jetbrains.com/plugin/24072-augment" /> is easy and will take you less than a minute. Augment is compatible with all JetBrains IDEs, including WebStorm, PyCharm, and IntelliJ. You can find the Augment plugin in the JetBrains Marketplace and install it following the instructions below.

<img alt="Augment plugin in JetBrains Marketplace" />

## Installing Augment for JetBrains IDEs

<Note>
  For these instructions we'll use *JetBrains IntelliJ* as an example, anywhere
  you see *IntelliJ* replace the name of the JetBrains IDE you're using.

  In the case of Android Studio, which is based on IntelliJ, please ensure that your installation
  uses a runtime with JCEF. Go to <Command />, type <Command />
  and press <Keyboard />. Ensure the current runtime ends with `-jcef`; if not, select one **with JCEF** from the options
  below.
</Note>

<Steps>
  <Step title="Make sure you have the latest version of your IDE installed">
    You can download the latest version of JetBrains IDEs from the <ExternalLink href="https://www.jetbrains.com/ides/#choose-your-ide" />
    website. If you already have IntelliJ installed, you can update to the
    latest version by going to
    <Command />.
  </Step>

  <Step title="Open the Plugins settings in your IDE">
    From the menu bar, go to <Command />, or
    use the keyboard shortcut <Keyboard /> to open the
    Settings window. Select <Command /> from the sidebar.
  </Step>

  <Step title="Search for Augment in the marketplace">
    Using the search bar in the Plugins panel, search for
    <Command />.
  </Step>

  <Step title="Install the extension">
    Click <Command /> to install the extension. Then click
    <Command /> to close the Settings window.
  </Step>

  <Step title="Sign into Augment and get coding">
    Sign in to by clicking <Command /> in the Augment
    panel. If you do not see the Augment panel, use the shortcut
    <Keyboard /> or click the Augment icon
    <img /> in the side bar of your IDE. See more details in [Sign
    In](/setup-augment/sign-in).
  </Step>
</Steps>

## Installing Beta versions of Augment for JetBrains IDEs

In order to get a specific bug fix or feature, sometimes you may need to *temporarily* install a beta version of Augment for JetBrains IDEs.
To do this, follow the steps below:

<Steps>
  <Step title="Download an archive of the beta version">
    You can download the latest beta version of Augment from <ExternalLink href="https://plugins.jetbrains.com/plugin/24072-augment/versions/beta?noRedirect=true" />
    website. Please click <Command /> on the latest version and save the archive to disk.
  </Step>

  <Step title="Open the Plugins settings in your IDE">
    From the menu bar, go to <Command />, or
    use the keyboard shortcut <Keyboard /> to open the
    Settings window. Select <Command /> from the sidebar.
  </Step>

  <Step title="Install Augment from the downloaded archive">
    Click on the gear icon next to <Command /> tab and click <Command />.
    Select the archive you downloaded in the previous step and click <Command />.
  </Step>
</Steps>


# Keyboard Shortcuts for JetBrains IDEs
Source: https://docs.augmentcode.com/jetbrains/setup-augment/jetbrains-keyboard-shortcuts

Augment integrates with your IDE to provide keyboard shortcuts for common actions. Use these shortcuts to quickly accept suggestions, write code, and navigate your codebase.

## About keyboard shortcuts

Augment is deeply integrated into your IDE and utilizes many of the standard keyboard shortcuts you are already familiar with. These shortcuts allow you to quickly accept suggestions, write code, and navigate your codebase. We also suggest updating a few keyboard shortcuts to make working with code suggestions even easier.

<Tabs>
  <Tab title="MacOS">
    To update keyboard shortcuts, use one of the following:

    | Method   | Action                          |
    | :------- | :------------------------------ |
    | Keyboard | <Keyboard /> select <Command /> |
    | Menu bar | <Command />                     |

    ## General

    | Action             | Default shortcut |
    | :----------------- | :--------------- |
    | Open Augment panel | <Keyboard />     |

    ## Chat

    | Action                   | Default shortcut |
    | :----------------------- | :--------------- |
    | Focus or open Chat panel | <Keyboard />     |

    ## Completions

    | Action                       | Default shortcut |
    | :--------------------------- | :--------------- |
    | Accept entire suggestion     | <Keyboard />     |
    | Accept word-by-word          | <Keyboard />     |
    | Reject suggestion            | <Keyboard />     |
    | Toggle automatic completions | <Keyboard />     |
  </Tab>

  <Tab title="Windows/Linux">
    To update keyboard shortcuts, use one of the following:

    | Method   | Action                               |
    | :------- | :----------------------------------- |
    | Keyboard | <Keyboard /> then select <Command /> |
    | Menu bar | <Command />                          |

    ## General

    | Action             | Default shortcut |
    | :----------------- | :--------------- |
    | Open Augment panel | <Keyboard />     |

    ## Chat

    | Action                   | Default shortcut |
    | :----------------------- | :--------------- |
    | Focus or open Chat panel | <Keyboard />     |

    ## Completions

    | Action                       | Default shortcut |
    | :--------------------------- | :--------------- |
    | Accept entire suggestion     | <Keyboard />     |
    | Accept word-by-word          | <Keyboard />     |
    | Reject suggestion            | <Keyboard />     |
    | Toggle automatic completions | <Keyboard />     |
  </Tab>
</Tabs>


# Setup Model Context Protocol servers
Source: https://docs.augmentcode.com/jetbrains/setup-augment/mcp

Use Model Context Protocol (MCP) servers with Augment to expand Augment's capabilities with external tools and data sources.

## About Model Context Protocol servers

Augment Agent can utilize external integrations through Model Context Protocol (MCP) to access external systems for information and integrate tools to take actions. MCP is an open protocol that provides a standardized way to connect AI models to different data sources and tools. MCP servers can be used to access local or remote databases, run automated browser testing, send messages to Slack or even play music on Spotify.

## Easy MCP: One-Click Integrations

> **New:** Easy MCP launched on July 30, 2025, making it easier than ever to connect popular developer tools to Augment Code.

Easy MCP is a new feature in the Augment Code extension that transforms complex MCP server setup into a single click. Instead of manually configuring servers, hunting for GitHub repos, or editing JSON files, you can now connect popular developer tools with just an API token or OAuth approval.

### Available Easy MCP Integrations

Easy MCP provides one-click access to these popular developer tools:

#### CircleCI

* **Context:** Build logs, test insights, flaky-test detection
* **Sample prompt:** "Find the latest failed pipeline on my branch and surface the failing tests."
* **Setup:** Click "+", paste your CircleCI API token, and you're connected.

#### MongoDB

* **Context:** Data exploration, database management, and context-aware code generation
* **Sample prompt:** "Analyze my user collection schema and suggest optimizations for our new search feature."
* **Setup:** One-click OAuth connection to your MongoDB instance.

#### Redis

* **Context:** Keyspace introspection, TTL audits, and migration helpers
* **Sample prompt:** "Generate a migration script to move expiring session keys to the new namespace."
* **Setup:** Connect with your Redis credentials in seconds.

### Getting Started with Easy MCP

1. Open the Augment Code extension in your JetBrains IDE
2. Navigate to the Easy MCP pane in the settings
3. Click the "+" button next to your desired integration
4. Paste an API token or approve OAuth
5. Start using the integration immediately in your Agent conversations

<img />

From that moment on, Augment Code streams your tool's live context into every suggestion and autonomous Agent run.

## Advanced Configuration: Settings Panel

For developers who need custom MCP server configurations or want to use servers not available through Easy MCP, you can configure MCP servers manually using the Augment Settings Panel.

To access the settings panel, select the gear icon in the upper right of the Augment panel. Once the settings panel is open, you will see a section for MCP servers.

<img />

Fill in the `name` and `command` fields. The `name` field must be a unique name for the server. The `command` field is the command to run the server. Environment variables have their own section and no longer need to be specified in the command.

<img />

To add additional servers, click the `+` button next to the `MCP` header.
To edit a configuration or to delete a server, click the `...` button next to the server name.

### Add a Remote MCP server

If your MCP server runs remotely (for example, a hosted service), click the "+ Add remote MCP" button in the MCP section. Remote MCP connections support both HTTP and SSE (Server‑Sent Events).

<img />

* Connection Type: choose HTTP or SSE
* Name: a unique display name for the server
* URL: the base URL to your MCP server (e.g., [https://api.example.com](https://api.example.com))

Remote MCP servers appear alongside your local MCP servers in the list. You can edit or remove them using the "..." menu next to the server name.

## Server compatibility

Not all MCP servers are compatible with Augment's models. The MCP standard, implementation of specific servers, and Augment's MCP support are frequently being updated, so check compatibility frequently.


# Index your workspace
Source: https://docs.augmentcode.com/jetbrains/setup-augment/workspace-indexing

When your workspace is indexed, Augment can provide tailored code suggestions and answers based on your unique codebase, best practices, coding patterns, and preferences. You can always control what files are indexed.

## About indexing your workspace

When you open a workspace with Augment enabled, your codebase will be automatically uploaded to Augment's secure cloud. You can control what files get indexed using `.gitignore` and `.augmentignore` files. Indexing usually takes less than a minute but can take longer depending on the size of your codebase.

## Security and privacy

Augment stores your code securely and privately to enable our powerful context engine. We ensure code privacy through a proof-of-possession API and maintain strict internal data minimization principles. [Read more about our security](https://www.augmentcode.com/security).

## What gets indexed

Augment will index all the files in your workspace, except for the files that match patterns in your `.gitignore` file and the `.augmentignore` file.

## Ignoring files with .augmentignore

The `.augmentignore` file is a list of file patterns that Augment will ignore when indexing your workspace. Create an `.augmentignore` file in the root of your workspace. You can use any glob pattern that is supported by the [gitignore](https://git-scm.com/docs/gitignore) file.

## Including files that are .gitignored

If you have a file or directory in your `.gitignore` that you want to indexed, you can add it to your `.augmentignore` file using the `!` prefix.

For example, you may want your `node_modules` indexed to provide Augment with context about the dependencies in their project, but it is typically included in their `.gitignore`. Add `!node_modules` to your `.augmentignore` file.

<CodeGroup>
  ```bash .augmentignore theme={null}
  # Include .gitignore excluded files with ! prefix
  !node_modules

  # Exclude other files with .gitignore syntax
  data/test.json
  ```

  ```bash .gitignore theme={null}
  # Exclude dependencies
  node_modules

  # Exclude secrets
  .env

  # Exclude build artifacts
  out
  build
  ```
</CodeGroup>


# Using Agent
Source: https://docs.augmentcode.com/jetbrains/using-augment/agent

Use Agent to complete simple and complex tasks across your workflow–implementing a feature, upgrade a dependency, or writing a pull request.

## About Agent

Augment Agent is a powerful tool that can help you complete software development tasks end-to-end. From quick edits to complete feature implementation, Agent breaks down your requests into a functional plan and implements each step all while keeping you informed about what actions and changes are happening. Powered by Augment's Context Engine and powerful LLM architecture, Agent can write, document, and test like an experienced member of your team.

## Accessing Agent

To access Agent, simply open the Augment panel and select one of the Agent modes from the drop down in the input box.

<img alt="Augment Agent" />

### Choosing a model

Use the model dropdown in the Augment panel to switch between Claude Sonnet 4 and GPT-5. Your selection applies only to Agent for the current workspace and can be changed at any time. See [Available Models](/models/available-models) for details.

## Using Agent

To use Agent, simply type your request into the input box using natural language and click the submit button. You will see the default context including current workspace, current file, and Agent memories. You can add additional context by clicking <AtIcon />and selecting files or folder, or add an image as context by clicking the paperclip. Agent can create, edit, or delete code across your workspace and can use tools like the terminal and external integrations through MCP to complete your request.

### Enhancing your prompt

You can improve the quality of your  by starting with a well crafted prompt. You can start with a quick or incomplete prompt and use the prompt enhancer to add relevant references, structure, and conventions from your codebase to improve the prompt before it is sent.

1. Write your prompt in the prompt input box
2. Click the Enhance Prompt ✨ button
3. Review and edit the enhanced prompt
4. Submit your prompt

### Reviewing changes

You can review every change Agent makes by clicking on the action to expand the view. Review diffs for file changes, see complete terminal commands and output, and the results of external integration calls.

<img alt="Augment Agent" />

### Checkpoints

Checkpoints are automatically saved snapshots of your workspace as Agent implements the plan allowing you to easily revert back to a previous step. This enables Agent to continue working while you review code changes and commands results. To revert to a previous checkpoint, click the reverse arrow to restore your code.

<img alt="Augment Agent" />

### Agent vs Agent Auto

By default, Agent will pause work when it needs to execute a terminal command or access external integrations. After reviewing the suggested action, click the blue play button to have Agent execute the command and continue working. You tell Agent to skip a specific action by clicking on the three dots and then Skip.

<img alt="Augment Agent" />

In Agent Auto, Agent will act more independently. It will edit files, execute terminal commands, and access tools like MCP servers automatically.

### Stop or guide the Agent

You can interrupt the Agent at any time by clicking Stop. This will pause the action to allow you to correct something you see the agent doing incorrectly. While Agent is working, you can also prompt the Agent to try a different approach which will automatically stop the agent and prompt it to correct its course.

<img alt="Stopping the agent" />

### Quick Ask Mode

Quick Ask Mode is a toggle button in the agent chat interface that restricts the AI to read-only tools only. When activated, it adds a visual badge to the message and focuses the AI on information gathering without making any changes to your codebase.

<img alt="Quick Ask Mode toggle and usage" />

### Comparison to Chat

Agent takes Chat to the next level by allowing Augment to do things for you-that is create and make modifications directly to your codebase. Chat can explain code, create plans, and suggest changes which you can smartly apply one-by-one, but Agent takes it a step further by automatically implementing the entire plan and all code changes for you.

| What are you trying to do?                       | Chat | Agent |
| :----------------------------------------------- | :--: | :---: |
| Ask questions about your code                    |  ☑️  |   ✅   |
| Get advice on how to refactor code               |  ☑️  |   ✅   |
| Add new features to selected lines of code       |  ☑️  |   ✅   |
| Add new feature spanning multiple files          |      |   ✅   |
| Document new features                            |      |   ✅   |
| Queue up tests for you in the terminal           |      |   ✅   |
| Open Linear tickets or start a pull request      |      |   ✅   |
| Start a new branch in GitHub from recent commits |      |   ✅   |
| Automatically perform tasks on your behalf       |      |   ✅   |

### Use cases

Use Agent to handle various aspects of your software development workflow, from simple configuration changes to complex feature implementations. Agent supports your daily engineering tasks like:

* **Make quick edits** - Create a pull request to adjust configuration values like feature flags from FALSE to TRUE
* **Perform refactoring** - Move functions between files while maintaining coding conventions and ensuring bug-free operation
* **Start a first draft for new features** - Start a pull request (PR) with implementing entirely new functionality straight from a GitHub Issue or Linear Ticket
* **Branch from GitHub** - Open a PR from GitHub based on recent commits that creates a new branch
* **Query Supabase tables directly** - Ask Agent to view the contents of a table
* **Start tickets in Linear or Jira** - Open tickets and ask Agent to suggest a plan to address the ticket
* **Add Pull Request descriptions** - Merge your PR into a branch then tell the agent to explain what the changes are and why they were made
* **Create test coverage** - Generate unit tests for your newly developed features
* **Generate documentation** - Produce comprehensive documentation for your libraries and features
* **Start a README** - Write a README for a new feature or updated function that you just wrote
* **Track development progress** - Review and summarize your recent Git commits for better visibility with the GitHub integration

## Next steps

* [Configure Agent Integrations](/jetbrains/setup-augment/agent-integrations)


# Using Chat
Source: https://docs.augmentcode.com/jetbrains/using-augment/chat

Use Chat to explore your codebase, quickly get up to speed on unfamiliar code, and get help working through a technical problem.

## About Chat

Chat is a new way to work with your codebase using natural language. Chat will automatically use the current workspace as context and you can [provide focus](/using-augment/chat-context) for Augment by selecting specific code blocks, files, folders, or external documentation. Details from your current chat, including the additional context, are used to provide more relevant code suggestions as well.

<img alt="Augment Chat" />

## Accessing Chat

Access the Chat sidebar by clicking the Augment icon <img /> in the sidebar or the status bar. You can also open Chat by using one of the keyboard shortcuts below.

**Keyboard Shortcuts**

| Platform      | Shortcut     |
| :------------ | :----------- |
| MacOS         | <Keyboard /> |
| Windows/Linux | <Keyboard /> |

## Using Chat

To use Chat, simply type your question or command into the input field at the bottom of the Chat panel. You will see the currently included context which includes the workspace and current file by default. Use Chat to explain your code, investigate a bug, or use a new library. See [Example Prompts for Chat](/using-augment/chat-prompts) for more ideas on using Chat.

### Enhancing your prompt

You can improve the quality of your  by starting with a well crafted prompt. You can start with a quick or incomplete prompt and use the prompt enhancer to add relevant references, structure, and conventions from your codebase to improve the prompt before it is sent.

1. Write your prompt in the prompt input box
2. Click the Enhance Prompt ✨ button
3. Review and edit the enhanced prompt
4. Submit your prompt

### Conversations about code

To get the best possible results, you can go beyond asking simple questions or commands, and instead have a back and forth conversation with Chat about your code. For example, you can ask Chat to explain a specific function and then ask follow-up questions about possible refactoring options. Chat can act as a pair programmer, helping you work through a technical problem or understand unfamiliar code.

### Starting a new chat

You should start a new Chat when you want to change the topic of the conversation since the current conversation is used as part of the context for your next question. To start a new chat, open the Augment panel and click the new chat icon <NewChatIcon /> at the top-right of the Chat panel.

### Previous chats

You can continue a chat by clicking the chevron icon<ChevronRightIcon />at the top-left of the Chat panel. Your previous chats will be listed in reverse chronological order, and you can continue your conversation where you left off.

### Deleting a chat

You can delete a previous chat by clicking the chevron icon<ChevronRightIcon />at the top-left of the Chat panel to show the list of previous chats. Click the delete icon <DeleteIcon /> next to the chat you want to delete. You will be asked to confirm that you want to delete the chat.


# Using Actions in Chat
Source: https://docs.augmentcode.com/jetbrains/using-augment/chat-actions

Actions let you take common actions on code blocks without leaving Chat. Explain, improve, or find everything you need to know about your codebase.

<img alt="Augment Chat Actions" />

## Using actions in Chat

To use a quick action, you an use a <Keyboard /> command or click the up arrow icon<ArrowUpIcon />to show the available actions. For explain, fix, and test actions, first highlight the code in the editor and then use the command.

| Action       | Usage                                                                    |
| :----------- | :----------------------------------------------------------------------- |
| <Keyboard /> | Use natural language to find code or functionality                       |
| <Keyboard /> | Augment will explain the hightlighted code                               |
| <Keyboard /> | Augment will suggest improvements or find errors in the highlighted code |
| <Keyboard /> | Augment will suggest tests for the highlighted code                      |

Augment will typically include code blocks in the response to the action. See [Applying code blocks from Chat](/using-augment/chat-apply) for more details.


# Applying code blocks from Chat
Source: https://docs.augmentcode.com/jetbrains/using-augment/chat-apply

Use Chat to explore your codebase, quickly get up to speed on unfamiliar code, and get help working through a technical problem.

<img alt="Augment Chat Apply" />

## Using code blocks from within Chat

Whenever Chat responds with code, you will have the option to add the code to your codebase. The most common option will be shown as a button and you can access the other options by clicking the overflow menu icon<MoreVertIcon />at the top-right of the code block. You can use the following options to apply the code:

* <FileCopyIcon />**Copy**
  the code from the block to your clipboard
* <FileNewIcon />**Create**
  a new file with the code from the block
* <CheckIcon />**Apply**
  the code from the block intelligently to your file


# Focusing Context in Chat
Source: https://docs.augmentcode.com/jetbrains/using-augment/chat-context

You can specify context from files, folders, and external documentation in your conversation to focus your chat responses.

## About Chat Context

Augment intelligently includes context from your entire workspace based on the ongoing conversation–even if you don't have the relevant files open in your editor–but sometimes you want Augment to prioritize specific details for more relevant responses.

<video />

### Focusing context for your conversation

You can specify context by clicking the <AtIcon /> icon at the top-left of the Chat panel or by <Command /> in the input field. You can use fuzzy search to filter the list of context options quickly. There are a number of different types of additional context you can add to your conversation:

1. Highlighted code blocks
2. Specific files or folders within your workspace
3. 3rd party documentation, like Next.js documentation

#### Mentioning files and folders

Include specific files or folders in your context by typing `@` followed by the file or folder name. For example, `@routes.tsx` will include the `routes.tsx` file in your context. You can include multiple files or folders.

#### Mentioning 3rd party documentation

You can also mention 3rd party documentation in your context by typing `@` followed by the name of the documentation. For example, `@Next.js` will include Next.js documentation in your context. Augment provides nearly 300 documentation sets spanning across a wide range of domains such as programming languages, packages, software tools, and frameworks.


# Example Prompts for Chat
Source: https://docs.augmentcode.com/jetbrains/using-augment/chat-prompts

Using natural language to interact with your codebase unlocks a whole new way of working. Learn how to get the most out of Chat with the following example prompts.

## About chatting with your codebase

Augment's Chat has deep understanding about your codebase, dependencies, and best practices. You can use Chat to ask questions about your code, but it also can help you with general software engineering questions, think through technical decisions, explore new libraries, and more.

## Enhancing your prompt

You can improve the quality of your  by starting with a well crafted prompt. You can start with a quick or incomplete prompt and use the prompt enhancer to add relevant references, structure, and conventions from your codebase to improve the prompt before it is sent.

1. Write your prompt in the prompt input box
2. Click the Enhance Prompt ✨ button
3. Review and edit the enhanced prompt
4. Submit your prompt

## Example Prompts

### Explain code

* Explain this codebase to me
* How do I use the Twilio API to send a text message?
* Explain how generics work in TypeScript and give me a simple example

### Finding code

* Where are all the useEffect hooks that depend on the 'currentUser' variable?
* Find the decorators that implement retry logic across our microservices
* Find coroutines that handle database transactions without a timeout parameter

### Generate code

* Write a function to check if a string is a valid email address
* Generate a middleware function that rate-limits API requests using a sliding window algorithm
* Create a SQL query to find the top 5 customers who spent the most money last month

### Write tests

* Write integration tests for this API endpoint
* What edge cases have I not included in this test?
* Generate mock data for testing this customer order processing function

### Refactor and improve code

* This function is running slowly with large collections - how can I optimize it?
* Refactor this callback-based code to use async/await instead
* Rewrite this function in Rust

### Find and fix errors

* This endpoint sometimes returns a 500 error. Here's the error log - what's wrong?
* I'm getting 'TypeError: Cannot read property 'length' of undefined' in this component.
* Getting CORS errors when my frontend tries to fetch from the API


# Completions
Source: https://docs.augmentcode.com/jetbrains/using-augment/completions

Use code completions to get more done. Augment's radical context awareness means more relevant suggestions, fewer hallucinations, and less time hunting down documentation.

## About Code Completions

Augment's Code Completions integrates with your IDE's native completions system to give you autocomplete-like suggestions as you type. You can accept all of a suggestion, accept partial suggestions a word or a line at a time, or just keep typing to ignore the suggestion.

## Using Code Completions

To use code completions, simply start typing in your IDE. Augment will provide suggestions based on the context of your code. You can accept a suggestion by pressing <Keyboard />, or ignore it by continuing to type.

For example, add the following function to a TypeScript file:

```typescript theme={null}
function getUser(): Promise<User>;
```

As you type `getUser`, Augment will suggest the function signature. Press <Keyboard /> to accept the suggestion. Augment will continue to offer suggestions until the function is complete, at which point you will have a function similar to:

```typescript theme={null}
function getUser(): Promise<User> {
  return fetch("/api/user/1")
    .then((response) => response.json())
    .then((json) => {
      return json as User;
    });
}
```

### Accepting Completions

<Tabs>
  <Tab title="MacOS">
    <Tip>
      We recommend configuring a custom keybinding to accept a word or line, see
      [Keyboard shortcuts](/setup-augment/vscode-keyboard-shortcuts) for more
      details.
    </Tip>

    | Action                         | Default keyboard shortcut              |
    | :----------------------------- | :------------------------------------- |
    | Accept inline suggestion       | <Keyboard />                           |
    | Accept next word of suggestion | <Keyboard />                           |
    | Accept next line of suggestion | None (see above)                       |
    | Reject suggestion              | <Keyboard />                           |
    | Ignore suggestion              | Continue typing through the suggestion |
    | Toggle automatic completions   | VSCode: <Keyboard />                   |
    |                                | JetBrains: <Keyboard />                |
  </Tab>

  <Tab title="Windows/Linux">
    <Tip>
      We recommend configuring a custom keybinding to accept a word or line, see
      [Keyboard shortcuts](/setup-augment/vscode-keyboard-shortcuts) for more
      details.
    </Tip>

    | Action                         | Default keyboard shortcut              |
    | :----------------------------- | :------------------------------------- |
    | Accept inline suggestion       | <Keyboard />                           |
    | Accept next word of suggestion | <Keyboard />                           |
    | Accept next line of suggestion | None (see above)                       |
    | Reject suggestion              | <Keyboard />                           |
    | Ignore suggestion              | Continue typing through the suggestion |
    | Toggle automatic completions   | VSCode: <Keyboard />                   |
    |                                | JetBrains: <Keyboard />                |
  </Tab>
</Tabs>

### Disabling Completions

<Tabs>
  <Tab title="Visual Studio Code">
    You can disable automatic code completions by clicking the overflow menu icon<MoreVertIcon />at the top-right of the Augment panel, then selecting <Command />.
  </Tab>

  <Tab title="JetBrains IDEs">
    You can disable automatic code completions by clicking the Augment icon <img /> in the status bar at the bottom right corner of your IDE, then selecting <Command />.
  </Tab>
</Tabs>

### Enable Completions

<Tabs>
  <Tab title="Visual Studio Code">
    If you've temporarily disabled completions, you can re-enable them by clicking the overflow menu icon<MoreVertIcon />at the top-right of the Augment panel, then selecting <Command />.
  </Tab>

  <Tab title="JetBrains IDEs">
    If you've temporarily disabled completions, you can re-enable them by clicking the Augment icon <img /> in the status bar at the bottom right corner of your IDE, then selecting <Command />.
  </Tab>
</Tabs>


# Using Tasklist
Source: https://docs.augmentcode.com/jetbrains/using-augment/tasklist

Use Tasklist to break down complex problems into manageable steps, track progress, and collaborate with Agent on multi-step tasks.

## What is the Tasklist?

Augment's Tasklist helps the Agent create and refine a step-by-step plan for you to review. The Tasklist provides a structured interface for collaboration between you and the Agent, allowing you to break down complex problems into manageable, sequential steps.

<img alt="Tasklist Overview" />

## Why Tasklist?

Tasklist improves agent effectiveness on long or complex tasks by:

* **Maintaining context** across different conversations by moving your Tasklist to a new chat
* **Breaking down complex problems** into manageable, sequential steps
* **Gathering progress** across threads
* **Exploring alternative solutions** to completed tasks if you need to pivot
* **Streamlining your approach** to nebulous problems by deleting irrelevant steps once the path forward is clear

Tasklist provides a structured interface for collaboration and opens up possibilities for agent-to-agent collaboration. We hypothesize that an interface such as Tasklist could be a preferred way to interact with coding agents in the future.

## Tasklist in Action

<img alt="Tasklist demonstration" />

## Creating a New Task

### Automatic Creation

The Agent will usually create a Tasklist when it encounters a complex, multi-step problem. You can also ask the Agent to make a Tasklist for you by simply prompting "Start a Tasklist to..." then add the problem you are trying to tackle.

### Manual Creation

You can also manually create a Tasklist:

1. Switch to Tasklist using the checklist button next to Changes
2. Click the plus to add your first task
3. Alternatively, you can create a new task by typing in the gray prompt box at the bottom of the extension. Click **Add Task** from the dropdown arrow next to Send

<img alt="Creating a new task" />

## Running Tasks

To run a task, click the grey triangle (play button) next to the task. The Agent will begin executing the task and update its status as it progresses.

<img alt="Running a task" />

## Task Status Indicators

Task statuses are indicated by different colors and icons:

* **Empty circle** - Task has not yet started
* **Blue half circle** - Task is currently in progress
* **Green checkbox** - Task has been completed and is ready for review

<img alt="Task status indicators" />

## Subtasks

Augment Code automatically generates subtasks when needed. The Agent will automatically add and nest required subtasks under your initial tasks. You can edit and expand these subtasks just like any other task in the list. Likewise, you can remove subtasks you deem unnecessary.

<img alt="Subtasks example" />

## Managing Running Tasks

### Stopping a Task

You can treat any in-progress task like any prompt you might send the Agent. To stop what the Agent is doing and offer a corrective action, click the red square (stop button) and tell the Agent what you want it to do instead.

### Running All Tasks

The Agent can complete all the tasks sequentially by clicking the triangle (play button) at the top of the Tasklist.

## Reviewing Changes

You can review the changes made by the Agent after a task is completed by toggling between the Tasks and Changes view to see the diffs (differences) of the work done by the agent for each task.

<img alt="Reviewing changes in Tasks and Changes view" />

## Integration with Task Management Tools

### Jira and Linear Integration

The Tasklist is a perfect pairing with existing task management tools like Jira or Linear:

* Ask the Agent to create a Tasklist based on tickets inside Jira or Linear
* Further break down complex tickets into manageable steps
* Once your Tasklist is completed, you can ask the Agent to resolve the issue inside Jira or Linear and append the steps taken as a comment

### Standalone Usage

Don't use an issue tracker? No problem - use Tasklist to track issues you need to tackle across Threads.

## Best Practices

* **Be specific** when creating tasks to help the Agent understand exactly what needs to be done
* **Review and edit** the automatically generated subtasks to ensure they align with your goals
* **Use the stop function** to provide course corrections when the Agent is heading in the wrong direction
* **Leverage the Changes view** to review all modifications made during task execution
* **Move Tasklists** between conversations to maintain context across different chat sessions

## Next Steps

* [Learn more about Agent](/jetbrains/using-augment/agent)
* [Configure Agent Integrations](/jetbrains/setup-augment/agent-integrations)


# Available Models
Source: https://docs.augmentcode.com/models/available-models

The LLMs currently available in Augment and how we use them.

## Current models

Augment uses world-class large language models together with our Context Engine. We currently support the following models:

* Claude Haiku 4.5 by Anthropic
* Claude Opus 4.5 by Anthropic
* Claude Sonnet 4 by Anthropic
* Claude Sonnet 4.5 by Anthropic
* GPT-5.1 by OpenAI

## Choosing a model

You can select the model directly using the Model Picker in the Augment.

* In VS Code and JetBrains, open the Augment panel and use the model dropdown near the input box to switch models.
* In Auggie CLI, use the `/model` slash command or pass the `--model` flag with the desired model.
* Your selection applies only to Agent in that workspace and can be changed at any time.

If you don't pick a model, Augment will use your last selection or the default set by your organization.

## Model pricing

Augment uses a credit-based pricing system. Different models consume credits at different rates based on their capabilities and costs:

* **Sonnet 4.5**: Baseline credit consumption for balanced, complex tasks
* **Opus 4.5**: \~167% of Sonnet's cost - most capable model for the hardest tasks
* **Haiku 4.5**: \~30% of Sonnet's cost - ideal for quick, simple tasks
* **GPT-5.1**: \~75% of Sonnet's cost - great for medium-complexity work

<Card title="Credit-Based Pricing" icon="credit-card" href="/models/credit-based-pricing">
  Learn more about credit costs, see detailed examples, and discover tips for optimizing your credit usage
</Card>

## Feature compatibility

Both models support the core Augment Agent features:

* Deep code understanding with Augment's Context Engine
* Tool use (integrations and MCP), file edits, and multi-step planning

Some behaviors (e.g., wording or style) may vary slightly between models. We'll continue to refine prompts and guardrails to provide a consistent developer experience.

## Notes and transparency

* We may roll out model updates gradually. If you're part of a staged rollout, different workspaces or teammates may see updates at different times.
* For troubleshooting, you can share the request ID with our support team; they can confirm which model handled a specific request.

If you have questions about model availability or want to participate in early access programs, please reach out via Support.


# Credit-Based Pricing
Source: https://docs.augmentcode.com/models/credit-based-pricing

Understand how credits work and how different models consume credits at different rates.

## Overview

Augment uses a credit-based pricing system where different models consume credits at different rates to reflect their power and cost. This gives you the flexibility to choose the right model for each task based on complexity and budget.

## Credit costs by model

Each model consumes credits at different rates based on its capabilities and underlying costs. Here's how the models compare:

| Model                 | Credits per task\* | Relative cost   | Best for                                                                                                                 |
| :-------------------- | :----------------- | :-------------- | :----------------------------------------------------------------------------------------------------------------------- |
| **Claude Sonnet 4.5** | 293 credits        | Baseline (100%) | Balanced capability. Ideal for medium or large tasks and is optimized for complex or multi-step work.                    |
| **Claude Opus 4.5**   | 488 credits        | 167% of Sonnet  | Most capable model. Best for the hardest tasks requiring deep reasoning, nuanced understanding, and exceptional quality. |
| **Claude Haiku 4.5**  | 88 credits         | 30% of Sonnet   | Lightweight, fast reasoning. Best for quick edits and small tasks.                                                       |
| **GPT-5.1**           | 219 credits        | 75% of Sonnet   | Advanced reasoning and context. Builds great plans and works well for medium-size tasks.                                 |

<Info>
  \*Based on a standard medium-complexity task. Actual credit consumption varies based on task complexity, context size, and response length.
</Info>

## Example tasks

To illustrate the credit differences, here are examples of tasks and how much they cost with each model.

### Sonnet task: Fix a 500 error in an API endpoint

> The `/api/users/:id` endpoint returns 500 errors when a user has no associated organization. Add null checking and return a 404 with a clear error message instead. Test that users with organizations still work correctly.

**Credit cost:** 293 credits with Sonnet 4.5

| Model          | Credits     | Savings              |
| :------------- | :---------- | :------------------- |
| **Sonnet 4.5** | 293 credits | —                    |
| **Opus 4.5**   | 488 credits | Use for harder tasks |
| **Haiku 4.5**  | 88 credits  | 205 credits saved    |
| **GPT-5.1**    | 219 credits | 74 credits saved     |

***

### Opus task: Design and implement a multi-tenant billing system

> Our B2B SaaS platform needs a multi-tenant billing system. Currently we have a simple Stripe integration for single subscriptions, but we need to support:
>
> 1. **Usage-based billing**: Track API calls per tenant with tiered pricing (first 10k calls free, then \$0.001/call)
> 2. **Seat-based licensing**: Charge per active user with volume discounts
> 3. **Hybrid plans**: Combine base subscription + usage overages
> 4. **Invoice generation**: Monthly invoices with line-item breakdown by workspace
> 5. **Billing isolation**: Each tenant's billing data must be completely isolated
>
> Design the database schema, implement the metering service, integrate with Stripe's usage-based billing API, and ensure we handle edge cases like mid-cycle plan changes, prorations, and failed payments. Consider how this will scale to 10k+ tenants.

**Credit cost:** 976 credits with Opus 4.5

## Monitoring credit usage

You can track your credit consumption in multiple places:

### In your IDE

* **VS Code**: View credit usage in the Augment panel
* **JetBrains**: Check the Augment tool window for usage stats
* **Auggie CLI**: Monitor credits used per session

### On the web

Visit [app.augmentcode.com](https://app.augmentcode.com) to access detailed dashboards that show:

* Total credits used by your team
* Credit usage per team member
* Breakdown by model and activity
* Usage trends over time
* Remaining credits in your plan

<Note>
  Team administrators can access more detailed analytics to help optimize team usage and identify opportunities to save credits by using more efficient models for appropriate tasks.
</Note>

## Understanding your usage breakdown

When you view your usage analytics, you'll see credits organized by both **model** and **activity type**. Here's what each activity type means:

### Session types

These are the main session types you can use with Augment:

| Activity        | What it is                               |
| :-------------- | :--------------------------------------- |
| **Chat**        | Conversational chat session              |
| **Agent**       | Local agent session (in your IDE)        |
| **RemoteAgent** | Cloud-based agent session (asynchronous) |
| **CliAgent**    | Command-line agent session (Auggie CLI)  |

### Optional features

| Activity            | What it is                                                                                   |
| :------------------ | :------------------------------------------------------------------------------------------- |
| **Prompt Enhancer** | Appears when you use the Prompt Enhancer feature to improve your prompts before sending them |
| **Code Review**     | Automated code review for pull requests (when enabled for your repository)                   |

### Background activities

Augment performs lightweight processing in the background to keep your experience smooth:

| Activity                | What it does                                                              |
| :---------------------- | :------------------------------------------------------------------------ |
| **Context Compression** | Summarizes conversation history to keep long sessions fast and responsive |
| **System**              | General background processing that helps Augment work smoothly            |

These background activities use a small fraction of your total credit consumption. In most workflows, they're a minor part of overall usage.

## Tips for optimizing credit usage

1. **Match the model to the task**: Use Haiku for simple tasks, GPT-5.1 for medium tasks, Sonnet for complex work, and Opus for the hardest challenges
2. **Be specific in your prompts**: Clear, detailed instructions help models work more efficiently
3. **Break down large tasks**: Sometimes splitting a complex task into smaller ones can be more credit-efficient
4. **Review usage patterns**: Check your dashboards regularly to identify optimization opportunities
5. **Set team guidelines**: Establish best practices for model selection within your team

## Frequently asked questions

<AccordionGroup>
  <Accordion title="How are credits calculated?">
    Credits are consumed based on the model used, the size of the context (code being analyzed), and the length of the response generated. More complex tasks that require analyzing more code or generating longer responses will consume more credits.
  </Accordion>

  <Accordion title="What happens if I run out of credits?">
    When you run out of credits, you'll need to upgrade your plan or wait until your credits reset at the beginning of your next billing cycle. Team administrators can purchase additional credits or upgrade the team plan at any time.
  </Accordion>

  <Accordion title="Can I switch models mid-conversation?">
    Currently, you can switch models mid-conversation in **Auggie CLI** using the `/model` command. Each message will consume credits based on the model selected for that specific message. Model switching mid-conversation is not yet available in the IDE extensions (VS Code, JetBrains), but you can change your model selection between separate conversations.
  </Accordion>
</AccordionGroup>

## Related resources

<CardGroup>
  <Card title="Available Models" icon="brain" href="/models/available-models">
    Learn about the different AI models available in Augment
  </Card>

  <Card title="Pricing Plans" icon="credit-card" href="https://augmentcode.com/pricing">
    View current pricing plans and credit allocations
  </Card>

  <Card title="Teams Admin Guide" icon="users" href="/teams/teams-admin-guide">
    Manage team subscriptions and billing
  </Card>

  <Card title="Blog: Credit-Based Plans" icon="newspaper" href="https://www.augmentcode.com/blog/our-new-credit-based-plans-are-now-live">
    Read the full announcement about credit-based pricing
  </Card>
</CardGroup>


# Quickstart
Source: https://docs.augmentcode.com/quickstart

Augment is the developer AI for teams that deeply understands your codebase and how you build software. Your code, your dependencies, and your best practices are all at your fingertips.

### 1. Install the Augment extension

<CardGroup>
  <Card href="https://marketplace.visualstudio.com/items?itemName=augment.vscode-augment">
    <img alt="Visual Studio Code" />

    <h2>
      Visual Studio Code
    </h2>

    <p>Install Augment for Visual Studio Code</p>
  </Card>

  <Card href="https://plugins.jetbrains.com/plugin/24072-augment">
    <img alt="JetBrains IDEs" />

    <h2>
      JetBrains IDEs
    </h2>

    <p>Install Augment for JetBrains IDEs, including WebStorm, PyCharm, and IntelliJ</p>
  </Card>

  <Card href="/cli/setup-auggie/install-auggie-cli">
    <img alt="Auggie CLI" />

    <h2>
      Auggie CLI
    </h2>

    <p>
      All the power of Augment's agent, context engine, and tools in your terminal.
    </p>
  </Card>
</CardGroup>

### 2. Sign-in and sync your repository

For VS Code and JetBrains IDEs, follow the prompts in the Augment panel to [sign in](/setup-augment/sign-in) and [index your workspace](/setup-augment/workspace-indexing). If you don't see the Augment panel, press <Keyboard /> or click the Augment icon in the side panel of your IDE.

For Auggie CLI, use the command `auggie login` to sign in.

### 3. Start coding with Augment

<Steps>
  <Step title="Using Agent">
    Augment agent enables you to complete tasks using natural language. Ask Agent to explain your codebase, debugging an
    issue, or writing entire functions, tests, or features. See [Using
    Agent](/using-augment/agent) for more details.
  </Step>

  <Step title="Using Next Edit">
    Augment Next Edit keeps you moving through your tasks by guiding you step-by-step through complex or repetitive changes. Jump to the next suggestion–in the same file or across your codebase–by pressing <Keyboard />. See
    [Using Next Edit](/using-augment/next-edit) for more details.
  </Step>

  <Step title="Using instructions">
    Start using an Instruction by hitting <Keyboard /> and quickly write tests, refactor code, or craft any prompt in natural language to transform your code. See [Using
    Instructions](/using-augment/instructions) for more details.
  </Step>

  <Step title="Using completions">
    Augment provides inline code suggestions as you type. To accept the full
    suggestions, press <Keyboard />, or accept the suggestion one
    word at a time with <Keyboard />. See [Using
    Completions](/using-augment/completions) for more details.
  </Step>
</Steps>

<Next>
  * [Disable other code assistants](/troubleshooting/disable-copilot)
  * [Use keyboard shortcuts](/setup-augment/vscode-keyboard-shortcuts)
  * [Configure indexing](/setup-augment/workspace-indexing)
</Next>


# Agent Integrations
Source: https://docs.augmentcode.com/setup-augment/agent-integrations

Configure integrations for Augment Agent to access external services like GitHub, Linear, Jira, Confluence, Notion, Sentry, and Stripe.

## About Agent Integrations

Augment Agent can access external services through integrations to add additional context to your requests and take actions on your behalf. These integrations allow Augment Agent to seamlessly work with your development tools without leaving your editor.

Once set up, Augment Agent will automatically use the appropriate integration based on your request context. Or, you can always mention the service in your request to use the integration.

## Setting Up Integrations

To set up integrations with Augment Agent in VS Code, follow these steps:

1. Click the settings icon in the top right of Augment's chat window or press <Keyboard /> and select <Command />
2. Click "Connect" for the integration you want to set up

<img alt="Set up integrations in the settings page" />

You'll be redirected to authorize the integration with the appropriate service. After authorization, the integration will be available for use with Augment Agent.

## Native Integrations

## <div><div><GitHubLogo /></div> GitHub Integration</div>

Add additional context to your requests and take actions. Pull in information from a GitHub Issue, make the changes to your code (or have Agent do it for you), and open a Pull Request all without leaving your editor.

### Examples

* "Implement Issue #123 and open up a pull request"
* "Find all issues assigned to me"
* "Check the CI status of my latest commit"

For authorization details, see [GitHub documentation](https://docs.github.com/en/apps/oauth-apps/using-oauth-apps/authorizing-oauth-apps).

## <div><div><LinearLogo /></div> Linear Integration</div>

Read, update, comment on, and resolve your Linear issues within your IDE.

### Examples

* "Fix TES-1"
* "Create Linear tickets for these TODOs"
* "Help me triage these new bug reports"

For authorization details, see [Linear documentation](https://linear.app/docs/third-party-application-approvals).

## <div><div><JiraLogo /></div> Jira Integration</div>

Work on your Jira issues, create new tickets, and update existing ones.

### Examples

* "Show me all my assigned Jira tickets"
* "Create a Jira ticket for this bug"
* "Create a PR to fix SOF-123"
* "Update the status of PROJ-123 to 'In Progress'"

For authorization details, see [Jira documentation](https://support.atlassian.com/jira-software-cloud/docs/allow-oauth-access/).

## <div><div><ConfluenceLogo /></div> Confluence Integration</div>

Query existing documentation or update pages directly from your IDE. Ensure your team's knowledge base stays current without any context switching.

### Examples

* "Summarize our Confluence page on microservice architecture"
* "Find information about our release process in Confluence"
* "Update our onboarding docs to explain how we use Bazel"

For authorization details, see [Confluence documentation](https://developer.atlassian.com/cloud/confluence/oauth-2-3lo-apps/).

## <div><div><NotionLogo /></div> Notion Integration</div>

Search and retrieve information from your team's knowledge base - access documentation, meeting notes, and project specifications. This integration is currently READ-ONLY.

### Examples

* "Find Notion pages about our API documentation"
* "Show me the technical specs for the payment system"
* "What outstanding tasks are left from yesterday's team meeting?"

For authorization details, see [Notion documentation](https://www.notion.so/help/add-and-manage-connections-with-the-api#install-from-a-developer).

## <div><div><GleanLogo /></div> Glean Integration</div>

> **Note:** The Glean integration is in early access and thus is a little different from other integrations.
>
> * It is currently only available to enterprise customers.
> * It does not appear in the list of integrations in the settings panel.

The Glean integration lets the agent retrieve information from your team's internal data sources leveraging Glean's powerful search engine.

**To Enable the Glean Integration:** You'll need to be have administrator access to Augment and Glean. Follow the instructions on [https://app.augmentcode.com/gleanConfig](https://app.augmentcode.com/gleanConfig) and your agent will be ready to use Glean!

### Examples

* "Search Glean for past related incidents and how they were resolved"
* "Search Glean for why we're migrating to a new payment processor"

## Enhanced Native Integrations

> **New:** Enhanced native integrations for Sentry and Stripe launched on July 30, 2025, providing deeper, more seamless access to your error tracking and payment data.

### <div><div><SentryLogo /></div> Sentry Integration</div>

Search issues, errors, traces, logs, and releases. Create RCAs and AI-Generated fixes with Seer integration for comprehensive error tracking and resolution.

#### Examples

* "Diagnose the top unresolved crashes in my React Native app and propose fixes"
* "Show me all errors from the latest release and their impact"
* "Create a root cause analysis for the payment processing errors"
* "Find similar issues that were resolved and suggest fixes"

### <div><div><StripeLogo /></div> Stripe Integration</div>

Real-time payment events, refund status, subscription metrics, and secure tokenization. Available via both remote and local MCP servers with OAuth MCP support in public preview.

#### Examples

* "Create a dashboard showing failed payment intents in the last 24 hours and suggest retry logic"
* "Analyze subscription churn patterns and recommend retention strategies"
* "Show me all refunds processed this week and their reasons"
* "Generate a report on payment method performance"

## Next Steps

* [Configure additional tools with Easy MCP or advanced MCP setup](/setup-augment/mcp)
* Explore one-click integrations for CircleCI, MongoDB, and Redis through Easy MCP


# Rules & Guidelines for Agent and Chat
Source: https://docs.augmentcode.com/setup-augment/guidelines

You can provide custom rules and guidelines written in natural language to improve Agent and Chat with your preferences, best practices, styles, and technology stack.

## What are Rules & Guidelines?

Agent and Chat rules and guidelines are natural language instructions that can help Augment reply with more accurate and relevant responses. Rules and guidelines are perfect for telling Augment to take into consideration specific preferences, package versions, styles, and other implementation details that can’t be managed with a linter or compiler. You can create guidelines for a specific workspace or globally for all chats in your IDE; guidelines do not currently apply to Completions, Instructions, or Next Edit.

User Guidelines are defined under Settings and stored within your IDE to be used to guide preferences inside of the Agent and Chat. Workspace Guidelines and Rules are stored directly in your repository.

## Working with User Guidelines

<Info>
  User Guidelines are stored locally in your IDE and will be applied to all future chats in that IDE. Guidelines defined in VSCode will not propagate to JetBrains IDEs and vice versa.
</Info>

<img alt="Adding user guidelines" />

You can add user guidelines by clicking Context menu (@), starting an @-mention inside Chat, or clicking Settings > Rules and User Guidelines.

### Navigating from the Context menu (@) User Guidelines

1. @ mention and select `User Guidelines`
2. Enter your guidelines (see below for tips)
3. Press Escape to save or wait for autosave

### Navigating from Settings > User Guidelines and Rules

<img alt="Open rules and guidelines" />

1. In the top right corner, select the hamburger menu (⋯)
2. Select Settings
3. From the left menu in Augment Settings, select User Guidelines and Rules

## Working with Rules

You can craft Rules to guide Augment towards specific documentation, frameworks, workflows or workstyles.

Rules are files that live in the `.augment/rules` directory. Currently, we support 3 types of rules:

* **Always**: contents will be included in every user prompt
* **Manual**: needs to be tagged through @ attaching the Rules file manually
* **Auto**: Agent will automatically detect and attach rules based on a description field

### User Rules vs Workspace Rules

Rules can be defined at two levels:

| Scope     | Location                           | Availability                        |
| :-------- | :--------------------------------- | :---------------------------------- |
| User      | `~/.augment/rules/`                | Available in all workspaces         |
| Workspace | `<workspace_root>/.augment/rules/` | Available in current workspace only |

**User rules** are stored in your home directory and apply to all projects. Use these for personal preferences, coding style guidelines, or conventions you want to follow across all your work. User rules are always treated as **Always** type and are automatically included in every prompt regardless of any frontmatter configuration.

**Workspace rules** are stored in the project repository and apply only to that specific project. Use these for project-specific guidelines that should be shared with your team via version control. Workspace rules support all three types (Always, Manual, Auto) via frontmatter configuration.

### Hierarchical Rules

In addition to workspace-level rules, Augment supports **hierarchical rules** through `AGENTS.md` and `CLAUDE.md` files placed in subdirectories. When working on files in a subdirectory, Augment automatically discovers and applies rule files from that directory and all parent directories.

**How it works:**

1. When you work on a file, Augment looks for `AGENTS.md` and `CLAUDE.md` in the file's directory
2. It walks up the directory tree, checking each parent directory for these files
3. All discovered rules are included in the context for that work session
4. The search stops at the workspace root (workspace root rules are loaded separately)

**Example:**

```
my-project/
  AGENTS.md                  <- Always included (workspace root)
  src/
    AGENTS.md                <- Included when working in src/ or subdirs
    components/
      AGENTS.md              <- Included when working in src/components/
      Button.tsx
```

When working on `src/components/Button.tsx`, all three `AGENTS.md` files are loaded.

**Use cases:**

* Framework-specific guidelines (React rules in frontend/, Node.js rules in backend/)
* Module-specific conventions (API design patterns in api/)
* Team boundaries (different teams maintain their own standards)

<Note>Only `AGENTS.md` and `CLAUDE.md` files are discovered hierarchically. Files in `.augment/rules/` are only loaded from the workspace root.</Note>

### Importing Rules

**Augment** will automatically import rules if they are detected in the current workspace. Augment will look for markdown files, e.g., files ending with `*.md` or `*.mdx`. You can also manually import rules inside of Settings > Import rules.

<img alt="Import rules" />

### Importing Augment Memories into Rules or User Guidelines

Augment Memories are automatically created by the Agent. If you’ve ever modified the Memories or prompted the Agent to remember something you can import these preferences as Rules or User Guidelines.

1. From the prompt box, click on Augment Memories
2. Select the item you'd like to import and then click User Guidelines at the top of Augment Memories from inside the editor.
3. To add the memory as a Rule, you'll first need to add at least one rule using +Create new rule file. Now, you can select any information inside the Augment Memories and save it as a Rule.

<img alt="Move memories" />

## Working with Workspace Guidelines `.augment-guidelines` (legacy)

You can add an `.augment-guidelines` file to the root of a repository to specify a set of guidelines that Augment will follow for all Agent and Chat sessions on the codebase. The `.augment-guidelines` file should be added to your version control system so that everyone working on the codebase has the same guidelines.

### Tips for good rules and guidelines

* Provide guidelines as a list
* Use simple, clear, and concise language for your guidelines
* Asking for shorter or code-only answers may hurt response quality

### Examples

<AccordionGroup>
  <Accordion title="User Guideline Examples">
    * Ask for additional explanation e.g. `For Typescript code, explain what the code is doing in more detail`

    * Set a preferred language e.g. `Respond to questions in Spanish`
  </Accordion>

  <Accordion title="Rule Examples">
    * Add links to Google Docs, Notion or Confluence files that define goals, product requirements, or project objectives

    * Point to specific documentation e.g. `Python 3.13.5` for the dependencies inside your project

    * Outline templates or example code commonly used in your project

    * Establish consistent frameworks, coding styles, and architectural patterns across your codebase

    * Provide examples on codebase style. For example:
      * Information that ONLY applies to the specific files, functions, or code snippets
      * Vague or obvious preferences that aren't actionable
      * General statements about good programming practices that any user would want
  </Accordion>

  <Accordion title="Workspace Guideline Examples">
    * Identifying preferred libraries e.g. `pytest vs unittest`
    * Identifying specific patterns e.g. `For NextJS, use the App Router and server components`
    * Rejecting specific anti-patterns e.g. `a deprecated internal module`
    * Defining naming conventions e.g. `functions start with verbs`
  </Accordion>
</AccordionGroup>

## FAQs

<AccordionGroup>
  <Accordion title="How are Rules different from Guidelines?">
    Guidelines and Rules differ in how they are stored and their scope of influence.

    * **User Guidelines** are stored in the user’s local IDE storage that will persist across Chat & Agent sessions; however, they do not persist across workspaces.
    * **User Rules** are stored in `~/.augment/rules/` and apply to all workspaces. They are always treated as "Always" type and automatically included in every prompt.
    * **Workspace Rules** are stored within the repository under the `.augment/rules` root that will allow you to split up previous Guidelines into multiple files to more precisely define your preferences. Workspace rules support all three types (Always, Manual, Auto).
    * **Workspace Guidelines** (legacy) stored within the repository under the `.augment-guidelines` file are a legacy set of rules that can be edited by editing the `.augment-guidelines` in your repository. Augment will automatically import Workspace Guidelines as Rules which you can access under Settings > User Guidelines and Rules.
  </Accordion>

  <Accordion title="What are the current limitations?">
    * User Guidelines are currently limited to a maximum of 24,576 characters.
    * Workspace Guidelines + Rules are limited to a maximum of 49,512 characters. If we exceed these limits, the user will be notified in app and be applied in order of (manual rules, always + auto rules, .augment-guidelines)
    * For VSCode, Guidelines are available in plugin version 0.492.0 and above
    * For JetBrains IDEs, Rules are available in plugin version 0.249.1 and above
  </Accordion>
</AccordionGroup>

## See Also

* [Custom Rules and Guidelines (CLI)](/cli/rules) - Configure rules for Auggie CLI
* [Workspace Context](/setup-augment/workspace-context-vscode) - Understanding workspace configuration in VSCode
* [Chat Context](/using-augment/chat-context) - Learn about context in Chat


# Install Augment for Slack
Source: https://docs.augmentcode.com/setup-augment/install-slack-app

Ask Augment questions about your codebase right in Slack.

<Note>
  The Augment GitHub App is compatible with GitHub.com and GitHub Enterprise Cloud. GitHub Enterprise Server is not currently supported.
</Note>

## About Augment for Slack

Augment for Slack brings the power of Augment Chat to your team's Slack workspace. Mention <Command /> in any channel or start a DM with Augment to have deep codebase-aware conversations with your team.

*To protect your confidential information, Augment will not include repository context in responses when used in shared channels with external members.*

## Installing Augment for Slack

### 1. Install GitHub App

<CardGroup>
  <Card title="Install Augment GitHub App" href="https://github.com/apps/augmentcode/installations/new" icon={<GitHubLogo />}>
    GitHub App for Augment Chat in Slack
  </Card>
</CardGroup>

To enable Augment's rich codebase-awareness, install the Augment GitHub App and grant access to your desired repositories. Organization owners and repository admins can install the app directly; others will need owner approval. See [GitHub documentation](https://docs.github.com/en/apps/using-github-apps/installing-a-github-app-from-a-third-party) for details.

We recommend authorizing only the few active repositories you want accessible to Augment Slack users. You can modify repository access anytime in the GitHub App settings.

<img alt="Installing the GitHub app on a single repository" />

### 2. Install Slack App

<CardGroup>
  <Card title="Install Augment for Slack" href="https://slack.com/oauth/v2/authorize?client_id=3751018318864.7878669571030&scope=app_mentions:read,channels:history,channels:read,chat:write,groups:history,groups:read,im:history,im:read,im:write,mpim:history,mpim:read,mpim:write,reactions:read,reactions:write,users.profile:read,users:read,users:read.email,groups:write,commands,assistant:write&user_scope=identity.basic" icon={<SlackLogo />}>
    Slack App for Augment Code
  </Card>
</CardGroup>

Once you have the GitHub App installed, install the Augment Slack App. You'll need an Augment account and correct permissions to install Slack apps for your workspace.

Any workspace member can use the Slack app once installed. Contact us if you need to restrict access to specific channels or users.

### 3. Add Augment to the Slack Navigation Bar

Make Augment easily accessible by adding it to Slack's assistant-view navigation bar:

1. Click your profile picture → **Preferences** → **Navigation**
2. Under **App agents & assistants**, select **Augment**

*Note: Each user can customize this setting in their preferences.*

<Next>
  [Using Augment for Slack](/using-augment/slack)
</Next>


# Install Augment for Visual Studio Code
Source: https://docs.augmentcode.com/setup-augment/install-visual-studio-code

Augment in Visual Studio Code gives you powerful code completions, transformations, and chat capabilities integrated into your favorite code editor.

<CardGroup>
  <Card title="Get the Augment Extension" href="https://marketplace.visualstudio.com/items?itemName=augment.vscode-augment" icon={<VscodeLogo />}>
    Install Augment for Visual Studio Code
  </Card>
</CardGroup>

## About Installation

Installing <ExternalLink href="https://marketplace.visualstudio.com/items?itemName=augment.vscode-augment" /> is easy and will take you less than a minute. You can install the extension directly from the Visual Studio Code Marketplace or follow the instructions below.

<img alt="Augment extension in Visual Studio Code Marketplace" />

## Installing Augment for Visual Studio Code

<Steps>
  <Step title="Make sure you have the latest version of Visual Studio Code installed">
    You can download the latest version of Visual Studio Code from the <ExternalLink href="https://code.visualstudio.com/" />. If you already have Visual Studio Code installed, you can update to the latest version by going to <Command />.
  </Step>

  <Step title="Open the Extensions panel in Visual Studio Code">
    Click the Extensions icon in the sidebar to show
    the Extensions panel.
  </Step>

  <Step title="Search for Augment in the marketplace">
    Using the search bar in the Extensions panel, search for
    <Command />.
  </Step>

  <Step title="Install the extension">
    Click <Command /> to install the extension.
  </Step>

  <Step title="Sign into Augment and get coding">
    Sign in to by clicking <Command /> in the Augment
    panel. If you do not see the Augment panel, use the shortcut
    <Keyboard /> or click the Augment icon
    <img /> in the side bar of your IDE. See more details in [Sign
    In](/setup-augment/sign-in).
  </Step>
</Steps>

## About pre-release versions

We regularly publish pre-release versions of the Augment extension. To use the pre-release version, go to the Augment extension in the Extensions panel and click <Command /> and then <Command />.

Pre-release versions may sometimes contain bugs or otherwise be unstable. As with the released version, please report any problems by sending us [feedback](/troubleshooting/feedback).


# Setup Model Context Protocol servers
Source: https://docs.augmentcode.com/setup-augment/mcp

Use Model Context Protocol (MCP) servers with Augment to expand Augment's capabilities with external tools and data sources.

## About Model Context Protocol servers

Augment Agent can utilize external integrations through Model Context Protocol (MCP) to access external systems for information and integrate tools to take actions. MCP is an open protocol that provides a standardized way to connect AI models to different data sources and tools. MCP servers can be used to access local or remote databases, run automated browser testing, send messages to Slack, or even play music on Spotify.

## Easy MCP: One-Click Integrations

> **New:** Easy MCP launched on July 30, 2025, making it easier than ever to connect popular developer tools to Augment Code.

Easy MCP is a new feature in the Augment Code extension that transforms complex MCP server setup into a single click. Instead of manually configuring servers, hunting for GitHub repos, or editing JSON files, you can now connect popular developer tools with just an API token or OAuth approval.

### Available Easy MCP Integrations

Easy MCP provides one-click access to these popular developer tools:

#### CircleCI

* **Context:** Build logs, test insights, flaky-test detection
* **Sample prompt:** "Find the latest failed pipeline on my branch and surface the failing tests."
* **Setup:** Click "+", paste your CircleCI API token, and you're connected.

#### MongoDB

* **Context:** Data exploration, database management, and context-aware code generation
* **Sample prompt:** "Analyze my user collection schema and suggest optimizations for our new search feature."
* **Setup:** One-click OAuth connection to your MongoDB instance.

#### Redis

* **Context:** Keyspace introspection, TTL audits, and migration helpers
* **Sample prompt:** "Generate a migration script to move expiring session keys to the new namespace."
* **Setup:** Connect with your Redis credentials in seconds.

### Getting Started with Easy MCP

1. Open the Augment Code extension in VS Code
2. Navigate to the Easy MCP pane in the settings
3. Click the "+" button next to your desired integration
4. Paste an API token or approve OAuth
5. Start using the integration immediately in your Agent conversations

<img />

From that moment on, Augment Code streams your tool's live context into every suggestion and autonomous Agent run.

## Advanced MCP Configuration

For developers who need custom MCP server configurations or want to use servers not available through Easy MCP, you can still configure MCP servers manually.

There are three ways to configure MCP servers in Augment:

1. **Easy MCP** (recommended) - One-click integrations for popular tools
2. **Augment Settings Panel** - Manual configuration with a GUI
3. **Import from JSON** - Paste a JSON config to quickly add servers

MCP servers configured through the Settings Panel or Import from JSON are managed in the same place. After importing, you can edit or remove servers in the Settings Panel.

## Configure in the Augment Settings Panel

The easiest way to configure MCP servers is to use the Augment Settings Panel.
To access the settings panel, open the options menu in the upper right of the Augment panel and click the Settings option. Once the settings panel is open, you will see a section for MCP servers.

<img />

Fill in the `name` and `command` fields. The `name` field must be a unique name for the server. The `command` field is the command to run the server. Environment variables have their own section and no longer need to be specified in the command.

<img />

To add additional servers, click the `+` button next to the `MCP` header.
To edit a configuration, or to delete a server, click the `...` button next to the server name.

### Add a Remote MCP server

If your MCP server runs remotely (for example, a hosted service), click the "+ Add remote MCP" button in the MCP section. Remote MCP connections support both HTTP and SSE (Server‑Sent Events).

<img />

* Connection Type: choose HTTP or SSE
* Name: a unique display name for the server
* URL: the base URL to your MCP server (e.g., [https://api.example.com](https://api.example.com))

Remote MCP servers appear alongside your local MCP servers in the list. You can edit or remove them using the "..." menu next to the server name.

## Import from JSON

You can quickly add MCP servers by importing a JSON configuration from the Augment Settings Panel:

1. Open the Settings Panel (gear icon in the Augment panel)
2. In the MCP section, click <strong>Import from JSON</strong>
3. Paste a configuration like the following and click Save

<img />

**Example: Local command (Context7 via npx)**

```json theme={null}
{
  "mcpServers": {
    "Context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"]
    }
  }
}
```

**Example: Remote SSE endpoint**

```json theme={null}
{
  "mcpServers": {
    "test": {
      "url": "http://localhost:3001/sse",
      "type": "sse"
    }
  }
}
```

After importing, servers appear in the list where you can edit, test, or remove them. Ensure any required dependencies for the server are installed on your machine.

## Server compatibility

Not all MCP servers are compatible with Augment's models. The MCP standard, implementation of specific servers, and Augment's MCP support are frequently being updated, so check compatibility frequently.


# Sign in and out
Source: https://docs.augmentcode.com/setup-augment/sign-in

After you have installed the Augment extension, you will need to sign in to your account.

## About Authentication

You can sign in to Augment using one of the supported identity providers–Google or Microsoft–or sign in using your email address and a single-use code we send to you. During the process, you will be redirected to your browser to sign in to your account.

## Sign in

<Steps>
  <Step title="Sign in to Augment">
    Click the <Command /> button in the Augment panel. If you do not see the Augment panel press <Keyboard />. If you are using Visual Studio Code, you be asked to confirm going to Augment's authentication portal.
  </Step>

  <Step title="Sign in with your email">
    In your browser, you may sign in with Google, Microsoft, or by receiving a single-use code in your email.
  </Step>

  <Step title="Accept the terms and conditions">
    If this is the first time you've signed in to Augment, you will be asked to accept the terms and conditions.
  </Step>

  <Step title="Return to your IDE">
    You will be automically redirected back to your IDE and you will see the Augment icon
    change to
    <img /> in the status bar.
  </Step>

  <Step title="Sync your workspace">
    If this is your first time using Augment, or you are working on a new workspace, you will see the <Command /> in the Augment panel. Click the <Command /> button in the Augment panel to enable Augment's rich codebase awareness. See [Syncing your workspace](/setup-augment/workspace-indexing) to customize syncing behavior and learn more.
  </Step>
</Steps>

## Sign out

<Steps>
  <Step title="Show the Augment command menu">
    Press <Keyboard /> to show the Augment command menu.
  </Step>

  <Step title="Click Sign Out">Click <Command /> from the bottom of the commands menu.</Step>

  <Step title="You are now signed out of Augment">
    You will see the status bar icon change to orange and you will be signed out of Augment in all of your active workspaces.
  </Step>
</Steps>


# Allow Augment traffic from static IPs
Source: https://docs.augmentcode.com/setup-augment/static-ip-support

Locate Augment static IP addresses and configure firewalls, allowlists, and network policies for Augment Agent and its integrations.

Augment routes all outbound integration and remote-agent traffic through region specific static IP addresses. Add these IPs to your firewalls and allowlists when you need predictable source addresses for compliance or access control.

## When static IP support helps

**You likely need static IPs when**

* Your GitHub organization enforces IP allowlists.
* Internal APIs, artifact registries, or databases sit behind IP restricted networks.
* Corporate firewalls require a known source IP before allowing outbound agent traffic.
* You are connecting Augment remote agents to private cloud or on-prem systems.
* Compliance policies mandate tracking specific egress addresses.

**You probably do not need static IPs when**

* Integrated services such as GitHub, Linear, Slack, and others are accessible without IP restrictions.
* You only use Augment with SaaS tools that do not enforce IP allowlists.
* Your network does not block traffic based on source IP.

## Get the IP addresses for your region

<Callout type="info">
  Always perform the lookup from a network that mirrors the environment enforcing the allowlist so you can detect DNS filtering or caching differences.
</Callout>

### US region

```bash theme={null}
dig +short us-static.augmentcode.com
```

### EU region

```bash theme={null}
dig +short eu-static.augmentcode.com
```

The DNS record returns the exact set of IP addresses Augment uses for outbound traffic in that region. Addresses are stable, and repeated lookups should return the same list. Rerun the lookup periodically or set up monitoring so you are alerted if Augment adds new addresses.

## Add the IPs to common services

### GitHub Enterprise with IP restrictions

1. Run the lookup for your region.
2. In GitHub, open **Settings** -> **Security** -> **IP allow list**.
3. Add each Augment IP address with a clear description such as `Augment Agent`.

### Private artifact registries

Add the IP addresses to the allowlist for the registry host. For example, with a private npm registry include the addresses in the service configuration before agents pull packages.

### Corporate firewalls

1. Allow inbound traffic to your services from the Augment IP addresses.
2. Note the rules in your change management system for auditing.
3. Monitor firewall logs for denied connections from Augment IPs.

### API gateways

```yaml theme={null}
apiVersion: networking.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: allow-augment
spec:
  rules:
  - from:
    - source:
        ipBlocks:
        - "203.0.113.10/32"  # Replace with the Augment IPs you looked up
        - "203.0.113.11/32"
```

### Databases with IP allowlists

```sql theme={null}
-- PostgreSQL pg_hba.conf example
host    all    augment_user    203.0.113.10/32    md5
host    all    augment_user    203.0.113.11/32    md5
```

## Implementation checklist

* Use the DNS entry for the region where your Augment deployment runs (`us-static` or `eu-static`).
* Document which services rely on Augment IPs and who owns the configuration.
* Limit access to only the systems Augment needs, following least privilege.
* Review and confirm allowlist entries during regular security audits.
* Configure alerts for DNS changes or repeated blocked traffic from Augment IPs.

## Troubleshooting

**If integrations stop working**

1. Rerun `dig +short <region>-static.augmentcode.com` and confirm the addresses match your allowlists.
2. Review firewall or service logs for blocked requests from Augment IPs.
3. Update the allowlist if any addresses changed or were missed.

**If DNS queries fail**

```bash theme={null}
nslookup us-static.augmentcode.com
dig us-static.augmentcode.com A
dig us-static.augmentcode.com +noall +answer
```

Ensure local DNS resolvers can reach the Augment records and that caching layers are not serving stale results.

## Need help?

Contact Augment Support with your region, the affected integrations, and relevant firewall or allowlist details so the team can help you validate the configuration.


# Secrets Manager
Source: https://docs.augmentcode.com/setup-augment/user-secrets

Securely store and manage secrets for your development environment, including API keys, tokens, and credentials.

<Availability />

The Secrets Manager allows you to securely store and manage user-defined secrets that can be used in your development environment. It supports two types of secrets: **Environment Variables** and **Mounted Files**.

## Overview

The Secrets Manager provides a secure way to store sensitive information like API keys, database credentials, and configuration secrets. All secrets are encrypted and stored securely, with automatic redaction in logs to prevent accidental exposure.

## Accessing the Secrets Manager

Open the Settings Panel (gear icon in the Augment panel) and navigate to the **Secrets** section to manage your secrets.

## Secret Types

### Environment Variables

Environment variables are injected into your development environment and accessible via standard environment variable access patterns.

**Use cases:**

* API keys (GitHub tokens, OpenAI keys)
* Database connection strings
* Service endpoints
* Configuration flags

**How they work:**

* Secrets are made available as environment variables in your workspace
* Generated profile script at `/etc/profile.d/15-augment-secrets.sh`
* Automatically loaded in shell sessions

### Mounted Files

Mounted files are stored as actual files in your workspace filesystem at specified paths.

**Use cases:**

* SSH private keys
* Certificate files
* Configuration files
* Large secret content

**How they work:**

* Files are mounted to `/run/augment_secrets/` by default
* You specify the mount path when creating the secret
* Files are accessible via standard filesystem operations

## Security Features

* Secret values are never displayed by default
* All secret values are redacted in logs
* Each user can only access their own secrets

## Limits and Quotas

| Limit                | Default Value  |
| -------------------- | -------------- |
| Max secrets per user | 100            |
| Max secret size      | 4KB            |
| Max name length      | 255 characters |
| Max tags per secret  | 50             |

## Security Best Practices

1. **Use descriptive names**: Make secret purposes clear without exposing sensitive info
2. **Regular cleanup**: Remove unused secrets to minimize exposure
3. **Avoid logging values**: The system automatically redacts secrets in logs
4. **Use appropriate type**: Choose environment variables for simple values, mounted files for complex content


# Keyboard Shortcuts for Visual Studio Code
Source: https://docs.augmentcode.com/setup-augment/vscode-keyboard-shortcuts

Augment integrates with your IDE to provide keyboard shortcuts for common actions. Use these shortcuts to quickly accept suggestions, write code, and navigate your codebase.

## About keyboard shortcuts

Augment is deeply integrated into your IDE and utilizes many of the standard keyboard shortcuts you are already familiar with. These shortcuts allow you to quickly accept suggestions, write code, and navigate your codebase. We also suggest updating a few keyboard shortcuts to make working with code suggestions even easier.

<Tabs>
  <Tab title="MacOS">
    To update keyboard shortcuts, use one of the following:

    | Method          | Action                               |   |
    | :-------------- | :----------------------------------- | - |
    | Keyboard        | <Keyboard /> then <Keyboard />       |   |
    | Menu bar        | <Command />                          |   |
    | Command palette | <Keyboard /> then search <Command /> |   |

    ## General

    | Action                | Recommended shortcut |
    | :-------------------- | :------------------- |
    | Open Augment panel    | <Keyboard />         |
    | Show Augment commands | <Keyboard />         |

    ## Chat

    | Action                   | Default shortcut |
    | :----------------------- | :--------------- |
    | Focus or open Chat panel | <Keyboard />     |

    ## Next Edit

    | Action            | Default shortcut |
    | :---------------- | :--------------- |
    | Go to next        | <Keyboard />     |
    | Go to previous    | <Keyboard />     |
    | Accept suggestion | <Keyboard />     |
    | Reject suggestion | <Keyboard />     |

    ## Instructions

    | Action            | Default shortcut |
    | :---------------- | :--------------- |
    | Start instruction | <Keyboard />     |
    | Accept            | <Keyboard />     |
    | Reject            | <Keyboard />     |

    ## Completions

    | Action                         | Default keyboard shortcut              |
    | :----------------------------- | :------------------------------------- |
    | Accept inline suggestion       | <Keyboard />                           |
    | Accept next word of suggestion | <Keyboard />                           |
    | Accept next line of suggestion | None (see below)                       |
    | Reject suggestion              | <Keyboard />                           |
    | Ignore suggestion              | Continue typing through the suggestion |
    | Toggle automatic completions   | <Keyboard />                           |

    **Recommended shortcuts**

    We recommend updating your keybindings to include the following shortcuts to
    make working with code suggestions even easier. These changes update the
    default behavior of Visual Studio Code.

    | Action                         | Recommended shortcut |
    | :----------------------------- | :------------------- |
    | Accept next line of suggestion | <Keyboard />         |
  </Tab>

  <Tab title="Windows/Linux">
    To update keyboard shortcuts, use one of the following:

    | Method          | Action                               |
    | :-------------- | :----------------------------------- |
    | Keyboard        | <Keyboard /> then <Keyboard />       |
    | Menu bar        | <Command />                          |
    | Command palette | <Keyboard /> then search <Command /> |

    ## General

    | Action                | Recommended shortcut |
    | :-------------------- | :------------------- |
    | Open Augment panel    | <Keyboard />         |
    | Show Augment commands | <Keyboard />         |

    ## Chat

    | Action                   | Default shortcut |
    | :----------------------- | :--------------- |
    | Focus or open Chat panel | <Keyboard />     |

    ## Next Edit

    | Action            | Default shortcut |
    | :---------------- | :--------------- |
    | Go to next        | <Keyboard />     |
    | Go to previous    | <Keyboard />     |
    | Accept suggestion | <Keyboard />     |
    | Reject suggestion | <Keyboard />     |

    ## Instructions

    | Action            | Default shortcut |
    | :---------------- | :--------------- |
    | Start instruction | <Keyboard />     |
    | Accept            | <Keyboard />     |
    | Reject            | <Keyboard />     |

    ## Completions

    | Action                         | Default keyboard shortcut              |
    | :----------------------------- | :------------------------------------- |
    | Accept inline suggestion       | <Keyboard />                           |
    | Accept next word of suggestion | <Keyboard />                           |
    | Accept next line of suggestion | None (see below)                       |
    | Reject suggestion              | <Keyboard />                           |
    | Ignore suggestion              | Continue typing through the suggestion |
    | Toggle automatic completions   | <Keyboard />                           |

    **Recommended shortcuts**

    We recommend updating your keybindings to include the following shortcuts to
    make working with code suggestions even easier. These changes update default
    behavior of Visual Studio Code.

    | Action                         | Recommended shortcut |
    | :----------------------------- | :------------------- |
    | Accept next line of suggestion | <Keyboard />         |
  </Tab>
</Tabs>


# Add context to your workspace
Source: https://docs.augmentcode.com/setup-augment/workspace-context-vscode

You can add additional context to your workspace–such as additional repositories and folders–to give Augment a full view of your system.

<Availability />

## About Workspace Context

Augment is powered by its deep understanding of your code. Sometimes important parts of your system exist outside of the current workspace you have open in your IDE. For example, you may have seperate frontend and backend repositories or have many services across multiple repositories. Adding additional context to your workspace will improve the code suggestions and chat responses from Augment.

## View Workspace Context

To view your Workspace Context, click the folder icon <Icon icon="folder-open" /> in the top right corner of the Augment sidebar panel.

<img alt="Workspace Context" />

## Add context to your workspace

To add context to your workspace, click <Command /> at the bottom of the Source Folders section of the context manager. From the file browser select the folders you want to add to your workspace context and click <Command />.

## View sync status

When viewing Workspace Context, each file and folder will have an icon that indicates whether its sync status. The following icons indicate the sync status of each file in your workspace:

| Indicator | Status                                  |
| :-------: | :-------------------------------------- |
|  <img />  | Synced, or sync in progress             |
|  <img />  | Not synced                              |
|  <img />  | Some files within the folder are synced |


# Index your workspace
Source: https://docs.augmentcode.com/setup-augment/workspace-indexing

When your workspace is indexed, Augment can provide tailored code suggestions and answers based on your unique codebase, best practices, coding patterns, and preferences. You can always control what files are indexed.

## About indexing your workspace

When you open a workspace with Augment enabled, your codebase will be automatically uploaded to Augment's secure cloud. You can control what files get indexed using `.gitignore` and `.augmentignore` files. Indexing usually takes less than a minute but can take longer depending on the size of your codebase. In Visual Studio Code, you can use Workspace Context to [view what files are indexed](/setup-augment/workspace-context-vscode#view-index-status-in-visual-studio-code) and [add additional context](/setup-augment/workspace-context-vscode#add-context-to-your-workspace).

## Security and privacy

Augment stores your code securely and privately to enable our powerful context engine. We ensure code privacy through a proof-of-possession API and maintain strict internal data minimization principles. [Read more about our security](https://www.augmentcode.com/security).

## What gets indexed

Augment will index all the files in your workspace, except for the files that match patterns in your `.gitignore` file and the `.augmentignore` file. You can [view what files are indexed](/setup-augment/workspace-context-vscode#view-sync-status-in-visual-studio-code) in Workspace Context.

## Ignoring files with .augmentignore

The `.augmentignore` file is a list of file patterns that Augment will ignore when indexing your workspace. Create an `.augmentignore` file in the root of your workspace. You can use any glob pattern that is supported by the [gitignore](https://git-scm.com/docs/gitignore) file.

## Including files that are .gitignored

If you have a file or directory in your `.gitignore` that you want to indexed, you can add it to your `.augmentignore` file using the `!` prefix.

For example, you may want your `node_modules` indexed to provide Augment with context about the dependencies in their project, but it is typically included in their `.gitignore`. Add `!node_modules` to your `.augmentignore` file.

<CodeGroup>
  ```bash .augmentignore theme={null}
  # Include .gitignore excluded files with ! prefix
  !node_modules

  # Exclude other files with .gitignore syntax
  data/test.json
  ```

  ```bash .gitignore theme={null}
  # Exclude dependencies
  node_modules

  # Exclude secrets
  .env

  # Exclude build artifacts
  out
  build
  ```
</CodeGroup>


# Using Teams
Source: https://docs.augmentcode.com/teams/teams-admin-guide

Use Teams to collect individual Augment Code accounts (Indie, Standard, or Max plans) into a Team. Once established you can bundle billing for your organization.

## About Teams

If multiple people from your organization use Augment Code through our [Indie, Standard or Max plan](https://augmentcode.com/pricing), Teams gathers accounts together for better collaboration. Teams simplify account management, offer better access control and centralize billing. Team administrators have special privileges to invite members, manage seats, change plans, and control team settings. Teams are not available for Enterprise plans since this plan by defaults groups the entire organization.

<Note>
  Team settings and billing management are only accessible to accounts assigned as the administrator. Individual team members can view team information but cannot modify settings or manage subscriptions. To change which account is set as the administrator, contact [Augment Code Support](https://portal.usepylon.com/augment-code/forms/augment-support)
</Note>

## Team Roles and Permissions

### Administrator Role

* Can invite new team members or cancel pending invitations
* Can remove team members
* Can manage team seats (increase/decrease)
* Can change team plans
* Can view and manage billing information

### Member Role

* Can view team information
* Can leave the team (remove themselves)
* Cannot invite or remove other members
* Cannot manage billing or change plans

## Adding Team Members

To add team members, you must be an administrator with available seats on your plan.

1. **Navigate to Team from Account** - Go to your [Account](https://app.augmentcode.com/account/), and then select the "Team" tab

2. **Initiate Invitation** - Click "Add team member," enter the email address, and click "Send invitation"

3. **Invitation Status** - The invitation appears as "Pending" in your team members list and counts toward your seat allocation

4. **Acceptance** - The invitee receives an email with instructions to join. Once they authenticate with their Augment account (or create one), they become an active team member

<Note>
  Invitations expire after 7 days. Pending invitations can be cancelled before acceptance. If your team is at capacity, add more seats before inviting new members. You can send multiple invitations simultaneously using comma-separated emails.
</Note>

## Removing Team Members

To remove team members, you must be an administrator. Members can also remove themselves from a team.

1. **Navigate to Team from Account** - Go to your [Account](https://app.augmentcode.com/account/), select the "Team" tab, and find the member you want to remove

2. **Remove Member** - Click the three-dot menu (⋮) next to the member's name, select "Remove Member," and confirm the removal

3. **After Removal** - The member immediately loses access to team resources and their account reverts to individual status. For paid plans, the seat becomes available at the next billing cycle.

<Note>
  Leaving? [Ask Augment Code Support](https://support.augmentcode.com/) to grant administrator access to another account before removing yourself if you're the only administrator.
</Note>

### Cancelling Pending Invitations

To cancel a pending invitation, navigate to the team members list, filter by "Pending" status, click the three-dot menu next to the pending invitation, and select "Cancel Invitation."

## Managing Team Plans and Subscriptions

Augment offers flexible plans to meet your team's needs. Visit [augmentcode.com/pricing](https://augmentcode.com/pricing) for current plan options and pricing.

### Changing Plans

To change your team's plan, you must be a team administrator with a valid payment method for paid plans.

1. **Access Plan Selection** - Go to [Account](https://app.augmentcode.com/account/) then select Subscription and click "Change Plan" or "Upgrade"

2. **Select New Plan** - Review available plans, pricing, and included features for your team size

3. **Configure Details** - Set the number of seats needed and review pricing calculations

4. **Confirm** - Add or update your payment method if needed, review prorated charges or credits, and confirm the plan change

<Note>
  Plan changes may be immediate (upgrades, free to paid, trial to paid) or take effect at the end of your billing cycle (downgrades). Prorated charges and credits are calculated automatically for mid-cycle changes.
</Note>

### Managing Seats

**Adding Seats**

1. **Navigate to Team Settings** - Go to [Account](https://app.augmentcode.com/account/) then the Team tab and click "Manage Seats"

2. **Increase Seat Count** - Use the number control to increase seats and review the new monthly cost

3. **Save Changes** - Click "Save changes" to confirm. Additional seats are billed immediately (prorated) and the new monthly rate takes effect immediately

**Removing Seats**

1. **Check Current Usage** - Ensure you have unused seats. You cannot reduce seats below your active members plus pending invitations

2. **Decrease Seat Count** - Navigate to "Manage Seats," reduce the number using the control, and save changes

3. **Billing Impact** - Removed seats remain active until the next billing cycle. Credits are applied at the next billing period

## Troubleshooting

**Cannot add members - no seats available**

* Purchase additional seats or remove inactive members
* Cancel pending invitations to free up seat allocation

**Payment method required**

* Add a valid credit card in Account > Billing
* Ensure your payment method is not expired
* Contact support for payment issues

**Cannot remove last admin**

* Promote another member to admin first before removing yourself

**Invitation expired**

* Resend the invitation from the Team tab
* Verify the correct email address was used
* Check spam folders for the invitation email

For additional help, contact [Support](https://portal.usepylon.com/augment-code/forms/augment-support) or visit [docs.augmentcode.com](https://docs.augmentcode.com).

## Best Practices

**Regular Audits** - Review team membership monthly, remove inactive members promptly, and monitor seat utilization to optimize costs.

**Invitation Management** - Verify email addresses before sending invitations and follow up with invitees directly. Cancel unaccepted invitations after 48 hours to free up seats.

**Billing Optimization** - Right-size your seat count and plan seat changes for billing cycle boundaries to avoid prorated charges.

**Security** - Remove members immediately upon departure, regularly review admin permissions, and use company email addresses for all team members.


# Feedback
Source: https://docs.augmentcode.com/troubleshooting/feedback

We love feedback, and want to hear from you. We want to make the best AI-powered code assistant so you can get more done.

Feedback helps us improve, and we encourage you to share your feedback on every aspect of using Augment—from suggestion and chat response quality, to user experience nusances, and even how we can improve getting your feedback.

### Reporting a bug

To report a bug, please [contact support](https://support.augmentcode.com/). Include as much detail to reproduce the problem as possible; screenshots and videos are very helpful.

### Feedback on completions

We are always balancing the needs for speed and accuracy. We want to know when you get a poor suggestion, hallucination, or a completion that actually doesn't work. The History panel has a log of all of your completions; we encourage you to use it to send us feedback on the completions you've received.

<Note>
  Providing feedback directly in your IDE through the History panel is currently
  only available in Visual Studio Code.
</Note>

<Steps>
  <Step title="Open the History panel">
    Open the History panel by pressing <Keyboard />
    and then searching for `Augment: Show History` in the command menu.
  </Step>

  <Step title="Find the completion you want to report">
    Recent completions are listed in reverse chronological order. Locate the
    completion you want to report and add complete the feedback form.
  </Step>

  <Step title="Submit your feedback">
    After completing the form, click either the red button for bad completions
    or the green button for good completions.
  </Step>
</Steps>

### Feedback on chat

After each Chat interaction, you have the opportunity to provide feedback on the quality of the response. At the bottom of the response click either the thumbs up <Icon icon="thumbs-up" /> or thumbs down <Icon icon="thumbs-down" /> icon. Add additional information in the feedback field, and click `Send Feedback`.


# Jetbrains UI issues
Source: https://docs.augmentcode.com/troubleshooting/jetbrains-rendering-issues

Fix issues where the Augment panel is white, blank or not showing anything in JetBrains IDEs.

## About UI issues in JetBrains IDEs

Some users on newer versions of JetBrains IDEs (2025.1 and above) have reported that the Augment panel is white, blank or not
displaying anything at all. These issues stem from a change to the way JetBrains renders webviews, which is now
done in an out-of-process manner. Disabling out-of-process rendering has resolved a number of problems for users.

This is a known issue that impacts multiple plugins in the Jetbrains ecosystem. JetBrains is tracking the issue in IJPL-186252.

**Note**: If you are using a **JetBrains IDE 2025.2.3 on Windows**, we do not recommend disabling out-of-process rendering due
to a bug where the WebViews will render JS and CSS in plain text making it difficult to use Augment and any other WebViews. There
is a workaround for this issue <a href="https://youtrack.jetbrains.com/issue/JBR-9462/Markdown-rendering-broken-with-ide.browser.jcef.out-of-process.enabledfalse-after-upgrading-to-PyCharm-2025.2.3#focus=Comments-27-12792022.0-0">described here</a>.

If you experience issues after following the steps below, please [contact support](https://support.augmentcode.com/)
for further assistance.

### Disable out-of-process rendering

<Steps>
  <Step title="Open the Custom Properties editor">
    From the menu bar, go to <Command />. If the `idea.properties` file doesn't exist yet, you'll be prompted to create it.
  </Step>

  <Step title="Add the out-of-process rendering property">
    Add the following line to the properties file:

    ```
    ide.browser.jcef.out-of-process.enabled=false
    ```
  </Step>

  <Step title="Save and restart your IDE">
    Save the file and restart your JetBrains IDE for the changes to take effect.
  </Step>
</Steps>

After restarting, the Augment panel should render more consistently.


# Jetbrains panel steals focus
Source: https://docs.augmentcode.com/troubleshooting/jetbrains-stealing-focus

Fix issue where the Augment panel takes focus while typing in JetBrains IDEs.

## About focus issues in JetBrains IDEs

Some users on Linux systems have reported that the Augment Chat window steals focus from the editor while typing. This can interrupt your workflow and make it difficult to use the IDE effectively. This issue can be resolved by enabling off-screen rendering in your JetBrains IDE.

### Enable off-screen rendering

<Steps>
  <Step title="Open the Custom Properties editor">
    From the menu bar, go to <Command />. If the `idea.properties` file doesn't exist yet, you'll be prompted to create it.
  </Step>

  <Step title="Add the off-screen rendering property">
    Add the following line to the properties file:

    ```
    augment.off.screen.rendering=true
    ```
  </Step>

  <Step title="Save and restart your IDE">
    Save the file and restart your JetBrains IDE for the changes to take effect.
  </Step>
</Steps>

After restarting, the Augment panel should no longer steal focus from the editor while you're typing.


# Request IDs
Source: https://docs.augmentcode.com/troubleshooting/request-id

Request IDs are generated with every code suggestion and chat interaction. Our team may ask you to provide the request ID when you report a bug or issue.

## Finding a Request ID for Chat

<Steps>
  <Step title="Open the Chat panel">
    Open the Chat panel by clicking the Augment icon

    <img />

    in the action bar on the left side of your editor.
  </Step>

  <Step title="Open the chat thread">
    If the chat reply you are interested is in a previous chat thread, find the
    chat thread by clicking the <Icon icon="chevron-right" /> at the top of the
    chat panel and clicking the relevant chat thread.
  </Step>

  <Step title="Find the request ID">
    Find the reply in question and click the <Icon icon="link-simple" /> icon
    above the reply to copy the request ID to your clipboard.
  </Step>
</Steps>

## Finding a Request ID for Completions

<Steps>
  <Step title="Open the History panel">
    Open the History panel by pressing <Keyboard />
    and then searching for `Augment: Show History` in the command menu.
  </Step>

  <Step title="Find the request ID">
    Recent requests are listed in reverse chronological order. Locate the
    request you are interested in and copy the request ID by clicking on the
    request ID, for example:
    <br /> `-- Request ID: 7f67c0dd-4c80-4167-9383-8013b18836cb`
  </Step>
</Steps>


# Using Agent
Source: https://docs.augmentcode.com/using-augment/agent

Use Agent to complete simple and complex tasks across your workflow–implementing a feature, upgrade a dependency, or writing a pull request.

## About Agent

Augment Agent is a powerful tool that can help you complete software development tasks end-to-end. From quick edits to complete feature implementation, Agent breaks down your requests into a functional plan and implements each step all while keeping you informed about what actions and changes are happening. Powered by Augment's Context Engine and powerful LLM architecture, Agent can write, document, and test like an experienced member of your team.

## Accessing Agent

To access Agent, simply open the Augment panel and select one of the Agent modes from the drop down in the input box.

<img alt="Augment Agent" />

### Choosing a model

Use the model dropdown in the Augment panel to switch between models. Your selection applies only to Agent for the current workspace and can be changed at any time. See [Available Models](/models/available-models) for details.

## Using Agent

To use Agent, simply type your request into the input box using natural language and click the submit button. You will see the default context including current workspace, current file, and Agent memories. You can add additional context by clicking <AtIcon />and selecting files or folder, or add an image as context by clicking the paperclip. Agent can create, edit, or delete code across your workspace and can use tools like the terminal and external integrations through MCP to complete your request.

### Enhancing your prompt

You can improve the quality of your  by starting with a well crafted prompt. You can start with a quick or incomplete prompt and use the prompt enhancer to add relevant references, structure, and conventions from your codebase to improve the prompt before it is sent.

1. Write your prompt in the prompt input box
2. Click the Enhance Prompt ✨ button
3. Review and edit the enhanced prompt
4. Submit your prompt

### Reviewing changes

You can review every change Agent makes by clicking on the action to expand the view. Review diffs for file changes, see complete terminal commands and output, and the results of external integration calls.

<img alt="Augment Agent" />

### Checkpoints

Checkpoints are automatically saved snapshots of your workspace as Agent implements the plan allowing you to easily revert back to a previous step. This enables Agent to continue working while you review code changes and commands results. To revert to a previous checkpoint, click the reverse arrow icon to restore your code.

<img alt="Augment Agent" />

### Agent memories

Memories help the Agent remember important details about your workspace and your preferences for working in it. Memories are stored locally and are applied to all Agent requests. Memories can be added automatically by Agent, by clicking the remember button under a message, asking Agent to remember something, or by editing the Memories files directly.

<img alt="Stopping the agent" />

### Agent vs Agent Auto

By default, Agent will pause work when it needs to execute a terminal command or access external integrations. After reviewing the suggested action, click the blue play button to have Agent execute the command and continue working. You tell Agent to skip a specific action by clicking on the three dots and then Skip.

<img alt="Augment Agent" />

In Agent Auto, Agent will act more independently. It will edit files, execute terminal commands, and access tools like MCP servers automatically.

### Stop or guide the Agent

You can interrupt the Agent at any time by clicking Stop. This will pause the action to allow you to correct something you see the agent doing incorrectly. While Agent is working, you can also prompt the Agent to try a different approach which will automatically stop the agent and prompt it to correct its course.

<img alt="Stopping the agent" />

### Quick Ask Mode

Quick Ask Mode is a toggle button in the agent chat interface that restricts the AI to read-only tools only. When activated, it adds a visual badge to the message and focuses the AI on information gathering without making any changes to your codebase.

<img alt="Quick Ask Mode toggle and usage" />

### Comparison to Chat

Agent takes Chat to the next level by allowing Augment to do things for you-that is create and make modifications directly to your codebase. Chat can explain code, create plans, and suggest changes which you can smartly apply one-by-one, but Agent takes it a step further by automatically implementing the entire plan and all code changes for you.

| What are you trying to do?                       | Chat | Agent |
| :----------------------------------------------- | :--: | :---: |
| Ask questions about your code                    |  ☑️  |   ✅   |
| Get advice on how to refactor code               |  ☑️  |   ✅   |
| Add new features to selected lines of code       |  ☑️  |   ✅   |
| Add new feature spanning multiple files          |      |   ✅   |
| Document new features                            |      |   ✅   |
| Queue up tests for you in the terminal           |      |   ✅   |
| Open Linear tickets or start a pull request      |      |   ✅   |
| Start a new branch in GitHub from recent commits |      |   ✅   |
| Automatically perform tasks on your behalf       |      |   ✅   |

### Use cases

Use Agent to handle various aspects of your software development workflow, from simple configuration changes to complex feature implementations. Agent supports your daily engineering tasks like:

* **Make quick edits** - Create a pull request to adjust configuration values like feature flags from FALSE to TRUE
* **Perform refactoring** - Move functions between files while maintaining coding conventions and ensuring bug-free operation
* **Start a first draft for new features** - Start a pull request (PR) with implementing entirely new functionality straight from a GitHub Issue or Linear Ticket
* **Branch from GitHub** - Open a PR from GitHub based on recent commits that creates a new branch
* **Query Supabase tables directly** - Ask Agent to view the contents of a table
* **Start tickets in Linear or Jira** - Open tickets and ask Agent to suggest a plan to address the ticket
* **Add Pull Request descriptions** - Merge your PR into a branch then tell the agent to explain what the changes are and why they were made
* **Create test coverage** - Generate unit tests for your newly developed features
* **Generate documentation** - Produce comprehensive documentation for your libraries and features
* **Start a README** - Write a README for a new feature or updated function that you just wrote
* **Track development progress** - Review and summarize your recent Git commits for better visibility with the GitHub integration

## Next steps

* [Configure Agent Integrations](/setup-augment/agent-integrations)
* [Configure other tools with MCP](/setup-augment/mcp)


# Using Chat
Source: https://docs.augmentcode.com/using-augment/chat

Use Chat to explore your codebase, quickly get up to speed on unfamiliar code, and get help working through a technical problem.

## About Chat

Chat is a new way to work with your codebase using natural language. Chat will automatically use the current workspace as context and you can [provide focus](/using-augment/chat-context) for Augment by selecting specific code blocks, files, folders, or external documentation. Details from your current chat, including the additional context, are used to provide more relevant code suggestions as well.

<img alt="Augment Chat" />

## Accessing Chat

Access the Chat sidebar by clicking the Augment icon <img /> in the sidebar or the status bar. You can also open Chat by using one of the keyboard shortcuts below.

**Keyboard Shortcuts**

| Platform      | Shortcut     |
| :------------ | :----------- |
| MacOS         | <Keyboard /> |
| Windows/Linux | <Keyboard /> |

## Using Chat

To use Chat, simply type your question or command into the input field at the bottom of the Chat panel. You will see the currently included context which includes the workspace and current file by default. Use Chat to explain your code, investigate a bug, or use a new library. See [Example Prompts for Chat](/using-augment/chat-prompts) for more ideas on using Chat.

### Conversations about code

To get the best possible results, you can go beyond asking simple questions or commands, and instead have a back and forth conversation with Chat about your code. For example, you can ask Chat to explain a specific function and then ask follow-up questions about possible refactoring options. Chat can act as a pair programmer, helping you work through a technical problem or understand unfamiliar code.

### Enhancing your prompt

You can improve the quality of your  by starting with a well crafted prompt. You can start with a quick or incomplete prompt and use the prompt enhancer to add relevant references, structure, and conventions from your codebase to improve the prompt before it is sent.

1. Write your prompt in the prompt input box
2. Click the Enhance Prompt ✨ button
3. Review and edit the enhanced prompt
4. Submit your prompt

### Starting a new chat

You should start a new Chat when you want to change the topic of the conversation since the current conversation is used as part of the context for your next question. To start a new chat, open the Augment panel and click the new chat icon <NewChatIcon /> at the top-right of the Chat panel.

### Previous chats

You can continue a chat by clicking the chevron icon<ChevronRightIcon />at the top-left of the Chat panel. Your previous chats will be listed in reverse chronological order, and you can continue your conversation where you left off.

### Deleting a chat

You can delete a previous chat by clicking the chevron icon<ChevronRightIcon />at the top-left of the Chat panel to show the list of previous chats. Click the delete icon <DeleteIcon /> next to the chat you want to delete. You will be asked to confirm that you want to delete the chat.


# Using Actions in Chat
Source: https://docs.augmentcode.com/using-augment/chat-actions

Actions let you take common actions on code blocks without leaving Chat. Explain, improve, or find everything you need to know about your codebase.

<img alt="Augment Chat Actions" />

## Using actions in Chat

To use a quick action, you an use a <Keyboard /> command or click the up arrow icon<ArrowUpIcon />to show the available actions. For explain, fix, and test actions, first highlight the code in the editor and then use the command.

| Action       | Usage                                                                    |
| :----------- | :----------------------------------------------------------------------- |
| <Keyboard /> | Use natural language to find code or functionality                       |
| <Keyboard /> | Augment will explain the hightlighted code                               |
| <Keyboard /> | Augment will suggest improvements or find errors in the highlighted code |
| <Keyboard /> | Augment will suggest tests for the highlighted code                      |

Augment will typically include code blocks in the response to the action. See [Applying code blocks from Chat](/using-augment/chat-apply) for more details.


# Applying code blocks from Chat
Source: https://docs.augmentcode.com/using-augment/chat-apply

Use Chat to explore your codebase, quickly get up to speed on unfamiliar code, and get help working through a technical problem.

<img alt="Augment Chat Apply" />

## Using code blocks from within Chat

Whenever Chat responds with code, you will have the option to add the code to your codebase. The most common option will be shown as a button and you can access the other options by clicking the overflow menu icon<MoreVertIcon />at the top-right of the code block. You can use the following options to apply the code:

* <FileCopyIcon />**Copy**
  the code from the block to your clipboard
* <FileNewIcon />**Create**
  a new file with the code from the block
* <CheckIcon />**Apply**
  the code from the block intelligently to your file


# Focusing Context in Chat
Source: https://docs.augmentcode.com/using-augment/chat-context

You can specify context from files, folders, and external documentation in your conversation to focus your chat responses.

## About Chat Context

Augment intelligently includes context from your entire workspace based on the ongoing conversation–even if you don't have the relevant files open in your editor–but sometimes you want Augment to prioritize specific details for more relevant responses.

<video />

### Focusing context for your conversation

You can specify context by clicking the <AtIcon /> icon at the top-left of the Chat panel or by <Command /> in the input field. You can use fuzzy search to filter the list of context options quickly. There are a number of different types of additional context you can add to your conversation:

1. Highlighted code blocks
2. Specific files or folders within your workspace
3. 3rd party documentation, like Next.js documentation

#### Mentioning files and folders

Include specific files or folders in your context by typing `@` followed by the file or folder name. For example, `@routes.tsx` will include the `routes.tsx` file in your context. You can include multiple files or folders.

#### Mentioning 3rd party documentation

You can also mention 3rd party documentation in your context by typing `@` followed by the name of the documentation. For example, `@Next.js` will include Next.js documentation in your context. Augment provides nearly 300 documentation sets spanning across a wide range of domains such as programming languages, packages, software tools, and frameworks.


# Example Prompts for Chat
Source: https://docs.augmentcode.com/using-augment/chat-prompts

Using natural language to interact with your codebase unlocks a whole new way of working. Learn how to get the most out of Chat with the following example prompts.

## About chatting with your codebase

Augment's Chat has deep understanding about your codebase, dependencies, and best practices. You can use Chat to ask questions about your code, but it also can help you with general software engineering questions, think through technical decisions, explore new libraries, and more.

## Enhancing your prompt

You can improve the quality of your  by starting with a well crafted prompt. You can start with a quick or incomplete prompt and use the prompt enhancer to add relevant references, structure, and conventions from your codebase to improve the prompt before it is sent.

1. Write your prompt in the prompt input box
2. Click the Enhance Prompt ✨ button
3. Review and edit the enhanced prompt
4. Submit your prompt

## Example Prompts

### Explain code

* Explain this codebase to me
* How do I use the Twilio API to send a text message?
* Explain how generics work in TypeScript and give me a simple example

### Finding code

* Where are all the useEffect hooks that depend on the 'currentUser' variable?
* Find the decorators that implement retry logic across our microservices
* Find coroutines that handle database transactions without a timeout parameter

### Generate code

* Write a function to check if a string is a valid email address
* Generate a middleware function that rate-limits API requests using a sliding window algorithm
* Create a SQL query to find the top 5 customers who spent the most money last month

### Write tests

* Write integration tests for this API endpoint
* What edge cases have I not included in this test?
* Generate mock data for testing this customer order processing function

### Refactor and improve code

* This function is running slowly with large collections - how can I optimize it?
* Refactor this callback-based code to use async/await instead
* Rewrite this function in Rust

### Find and fix errors

* This endpoint sometimes returns a 500 error. Here's the error log - what's wrong?
* I'm getting 'TypeError: Cannot read property 'length' of undefined' in this component.
* Getting CORS errors when my frontend tries to fetch from the API


# Completions
Source: https://docs.augmentcode.com/using-augment/completions

Use code completions to get more done. Augment's radical context awareness means more relevant suggestions, fewer hallucinations, and less time hunting down documentation.

## About Code Completions

Augment's Code Completions integrates with your IDE's native completions system to give you autocomplete-like suggestions as you type. You can accept all of a suggestion, accept partial suggestions a word or a line at a time, or just keep typing to ignore the suggestion.

## Using Code Completions

To use code completions, simply start typing in your IDE. Augment will provide suggestions based on the context of your code. You can accept a suggestion by pressing <Keyboard />, or ignore it by continuing to type.

For example, add the following function to a TypeScript file:

```typescript theme={null}
function getUser(): Promise<User>;
```

As you type `getUser`, Augment will suggest the function signature. Press <Keyboard /> to accept the suggestion. Augment will continue to offer suggestions until the function is complete, at which point you will have a function similar to:

```typescript theme={null}
function getUser(): Promise<User> {
  return fetch("/api/user/1")
    .then((response) => response.json())
    .then((json) => {
      return json as User;
    });
}
```

### Accepting Completions

<Tabs>
  <Tab title="MacOS">
    <Tip>
      We recommend configuring a custom keybinding to accept a word or line, see
      [Keyboard shortcuts](/setup-augment/vscode-keyboard-shortcuts) for more
      details.
    </Tip>

    | Action                         | Default keyboard shortcut              |
    | :----------------------------- | :------------------------------------- |
    | Accept inline suggestion       | <Keyboard />                           |
    | Accept next word of suggestion | <Keyboard />                           |
    | Accept next line of suggestion | None (see above)                       |
    | Reject suggestion              | <Keyboard />                           |
    | Ignore suggestion              | Continue typing through the suggestion |
    | Toggle automatic completions   | VSCode: <Keyboard />                   |
    |                                | JetBrains: <Keyboard />                |
  </Tab>

  <Tab title="Windows/Linux">
    <Tip>
      We recommend configuring a custom keybinding to accept a word or line, see
      [Keyboard shortcuts](/setup-augment/vscode-keyboard-shortcuts) for more
      details.
    </Tip>

    | Action                         | Default keyboard shortcut              |
    | :----------------------------- | :------------------------------------- |
    | Accept inline suggestion       | <Keyboard />                           |
    | Accept next word of suggestion | <Keyboard />                           |
    | Accept next line of suggestion | None (see above)                       |
    | Reject suggestion              | <Keyboard />                           |
    | Ignore suggestion              | Continue typing through the suggestion |
    | Toggle automatic completions   | VSCode: <Keyboard />                   |
    |                                | JetBrains: <Keyboard />                |
  </Tab>
</Tabs>

### Disabling Completions

<Tabs>
  <Tab title="Visual Studio Code">
    You can disable automatic code completions by clicking the overflow menu icon<MoreVertIcon />at the top-right of the Augment panel, then selecting <Command />.
  </Tab>

  <Tab title="JetBrains IDEs">
    You can disable automatic code completions by clicking the Augment icon <img /> in the status bar at the bottom right corner of your IDE, then selecting <Command />.
  </Tab>
</Tabs>

### Enable Completions

<Tabs>
  <Tab title="Visual Studio Code">
    If you've temporarily disabled completions, you can re-enable them by clicking the overflow menu icon<MoreVertIcon />at the top-right of the Augment panel, then selecting <Command />.
  </Tab>

  <Tab title="JetBrains IDEs">
    If you've temporarily disabled completions, you can re-enable them by clicking the Augment icon <img /> in the status bar at the bottom right corner of your IDE, then selecting <Command />.
  </Tab>
</Tabs>


# Instructions
Source: https://docs.augmentcode.com/using-augment/instructions

Use Instructions to write or modify blocks of code using natural language. Refactor a function, write unit tests, or craft any prompt to transform your code.

<Availability />

## About Instructions

Augment's Instructions let you use natural language prompts to insert new code or modify your existing code. Instructions can be initiated by hitting <Keyboard /> and entering an instruction inside the input box that appears in the diff view. The change will be applied as a diff to be reviewed before accepting.

## Using Instructions

To start a new Instruction, there are two options. You can select & highlight the code you want to change or place your cursor where you want new code to be added, then press <Keyboard />. You'll be taken to a diff view where you can enter your prompt and see the results.

For example, you can generate new functions based on existing code:

```
> Add a getUser function that takes userId as a parameter
```

<img alt="Augment Instructions Diff" />

Your change will be made as a diff, so you can review the suggested updates before modifying your code. Use the following shortcuts or click the options in the UI to accept or reject the changes.

<Tabs>
  <Tab title="MacOS">
    | Action            | Shortcut     |
    | :---------------- | :----------- |
    | Start instruction | <Keyboard /> |
    | Accept            | <Keyboard /> |
    | Reject            | <Keyboard /> |
  </Tab>

  <Tab title="Windows/Linux">
    | Action            | Shortcut     |
    | :---------------- | :----------- |
    | Start instruction | <Keyboard /> |
    | Accept            | <Keyboard /> |
    | Reject            | <Keyboard /> |
  </Tab>
</Tabs>


# Next Edit
Source: https://docs.augmentcode.com/using-augment/next-edit

Use Next Edit to flow through complex changes across your codebase. Cut down the time you spend on repetitive work like refactors, library upgrades, and schema changes.


<Availability />

## About Next Edit

<iframe title="Feature Intro: Augment Next Edit" />

Next Edit helps you complete your train of thought by suggesting changes based on
your recent work and other context. You can jump to the next edit and quickly accept or
reject the suggested change with a single keystroke.

## Using Next Edit

<img />

When Next Edit has a suggestion available, you will see a gutter icon and a summary
of the change in gray at the end of the line.
To jump to the next suggestion, press <Keyboard /> and
after reviewing the change, press <Keyboard /> to accept
or <Keyboard /> to reject. If there are multiple
changes, press <Keyboard /> to accept and go to the
next suggestion.

<img />

<img />

By default, Next Edit will briefly highlight which parts of the existing code will
change before applying the change and highlighting the new code. Use Undo
(<Keyboard />) and Redo
(<Keyboard />) to manually review the change.
You can configure this behavior in your Augment extension settings.

### Keyboard Shortcuts

<Tabs>
  <Tab title="MacOS">
    | Action            | Default shortcut |
    | :---------------- | :--------------- |
    | Go to next        | <Keyboard />     |
    | Go to previous    | <Keyboard />     |
    | Accept suggestion | <Keyboard />     |
    | Reject suggestion | <Keyboard />     |
  </Tab>

  <Tab title="Windows/Linux">
    | Action            | Default shortcut |
    | :---------------- | :--------------- |
    | Go to next        | <Keyboard />     |
    | Go to previous    | <Keyboard />     |
    | Accept suggestion | <Keyboard />     |
    | Reject suggestion | <Keyboard />     |
  </Tab>
</Tabs>

### Next Edit Indicators And Actions

There are several indicators to let you know Next Edits are available:

<img />

1. **Editor Title Icon** (Top Right): Changes colors when next edits are available.
   Click on the <NextEditPencil /> icon to open the next edit menu for
   additional actions like enabling/disabling the feature or accessing settings.
2. **Gutter Icon** (Left) - Indicates which lines will be changed by the suggestion
   and whether it will insert, delete or change code.
3. **Grey Text** (Right) -  appears on the line with the suggestion on screen with a
   brief summary of the change and the keybinding to press (typically
   <Keyboard />).

<img />

4. **Hint Box** (Bottom Left) - appears when the next suggestion is off screen with
   brief summary of the change and the keybinding to press (typically
   <Keyboard />).

The tooltip also presents a few actions as icons:

* <NextEditDiffIcon /> Toggles showing diffs for suggestions in the tooltip.
* <NextEditSettingsIcon /> Opens Next Edit settings.

### Next Edit Settings

You can configure Next Edit settings in your Augment extension settings.
To open Augment extension settings, either navigate to the option through the pencil
menu, or open the Augment Commands panel by pressing
<Keyboard /> and select <Command />.

Here are some notable settings:

* <Command />: Use to enable or
  disable the feature.
* <Command />: When enabled, Next
  Edits will suggest changes in other files via the hint box.
* <Command />: When enabled, Next
  Edits will automatically apply changes when you jump to them.
* <Command />: When enabled,
  Next Edits will show a diff of the suggested change in the hover.
* <Command />: When enabled,
  Next Edits will highlight all lines with a suggestion in addition to showing gutter
  icons and grey text.


# Using Remote Agent
Source: https://docs.augmentcode.com/using-augment/remote-agent

Use Remote Agent to complete tasks across your workflow–implementing a feature, upgrade a dependency, or writing a pull request–all from the cloud and with the full power of Visual Studio Code when you need it.

## About Remote Agent

Augment Remote Agent is a powerful tool that can help you complete software development tasks end-to-end that runs in a secure, cloud environment. You can run multiple agents in parallel on independent tasks, and you'll monitor and manage their progress from within Visual Studio Code. Remote Agents can run in normal or auto mode, just like IDE-based agents, and will notify you when they need attention.

### How is Remote Agent different from Agent?

Remote Agent is a cloud version of the IDE-bound Agent. Each Remote Agent runs on its own secure environment, with its own workspace-all of which is managed for you. Each Remote Agent works independently and on its own branch, so you can have multiple agents working on the same repository at the same time.

## Accessing Remote Agent

To start a new Remote Agent, simply open the Augment panel and select Remote Agent from the drop down in the input box.

<img alt="Augment Remote Agent" />

### Agent dashboard

You can view all of your remote agents in the Remote Agent dashboard by clicking the <Command /> icon in the top of the Augment panel. From the dashboard you are able to see the status of all of your agents, connect to them through SSH, or delete them when they are no longer needed.

<img alt="Augment Agent" />

## Using Remote Agent

Remote Agents function nearly identically to IDE-bound agents as you work through your tasks and projects. Because they run asynchronously in the cloud, you can access and manage them while working on other projects in your editor. Access your Remote Agents from the threads menu at the top of the Augment panel or through the Remote Agent dashboard.

You can create and manage a Remote Agent for any repository you have access to through GitHub regardless of which project you are currently working on in your editor.

### Create a remote agent

<Note>
  Before you can use Remote Agent, you will need to connect your GitHub account to enable the agent to clone your repository, create branches, and open pull requests. See [Agent Integrations](/setup-augment/agent-integrations) for setup instructions.
</Note>

1. **Select the repository** you want the agent to work on
2. **Select the branch** or let the agent create a new branch for you
3. **Select an environment** or [create a new one](/using-augment/remote-agent-environment) for the agent to run in
4. Enter your prompt into the input box using natural language and click **Create agent**

<img alt="Create a Remote Agent" />

#### Agent environment

Each Remote Agent runs in an secure, independent environment in the cloud. This enables each agent to have its own workspace, copy of the repository, and virtualized operating system to run other tools and commands. You can use the [base environment](/using-augment/remote-agent-environment#base-environment), or setup a custom environment using a bash script to configure the tools the agent will need to complete the task.

See [Remote Agent Environment](/using-augment/remote-agent-environment) for more details on customizing the agent environment.

### Agent notifications

By default, you will receive a notification in VS Code when the agent has completed a task or needs your attention. You can disable notifications for a remote agent by clicking the bell icon in the theads list of the Augment panel.

### Iterating with an agent

Once an agent has completed the task, you can continue to iterate with the agent by sending additional messages. The agent will continue to work on the task, using its past conversations as context. If you need to switch to editing files directly, you can connect to the agent environment over SSH. See [Connecting to a Remote Agent](#connecting-to-a-remote-agent-environment) for more details.

### Reviewing changes

You can review every change Agent makes by clicking on the action to expand the view. Review diffs for file changes, see complete terminal commands and output, and the results of external integration calls.

<img alt="Augment Agent" />

### Stop or guide the Agent

You can interrupt the Agent at any time by clicking Stop. This will pause the action to allow you to correct something you see the agent doing incorrectly. While Agent is working, you can also prompt the Agent to try a different approach which will automatically stop the agent and prompt it to correct its course.

<img alt="Stopping the agent" />

### Connecting to a Remote Agent environment

<Note>
  You will need to have the [Remote-SSH extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-ssh) installed in Visual Studio Code to connect to a remote agent. If you do not have it installed, you will be prompted to install it automatically.
</Note>

From time to time you may need to connect to a remote agent to view or edit files directly, in that case you can connect to the agent environment over SSH. From the Remote Agent dashboard, click the <Command /> button in the agent card you with to connect to.

This will open a Visual Studio Code window connected to the agent's environment. If this is your first time opening the connection, you will be prompted by VS Code to trust the files in the remote folder. Click <Command /> to continue.

<img alt="Augment Agent" />

You can use the new VS Code window to view and edit files, run commands in the terminal, and generally interact with the agent just like you would a local IDE-bound agent.

### Opening a Pull Request

When the agent has completed the work, you can open a pull request to have your changes opened for review and merging into the main branch. Select the agent from the threads list and click <Command />. The agent will create a branch, commit the changes, and open a pull request for you. This will count against your credits quota.

<img alt="Augment Agent Pull Request" />

### Resuming a Remote Agent

Remote Agents automatically pause after completing a request or remaining idle for a period of time. To resume a paused Remote Agent, either click <Command /> or send a new message to the agent. Both actions will count against your credits quota.

## Comparison chart

Agent takes Chat to the next level by allowing Augment to do things for you-that is create and make modifications directly to your codebase. Chat can explain code, create plans, and suggest changes which you can smartly apply one-by-one, but Agent takes it a step further by automatically implementing the entire plan and all code changes for you.

| What are you trying to do?                       | Chat | Agent | Remote Agent |
| :----------------------------------------------- | :--: | :---: | :----------: |
| Ask questions about your code                    |  ☑️  |   ✅   |       ✅      |
| Get advice on how to refactor code               |  ☑️  |   ✅   |       ✅      |
| Add new features to selected lines of code       |  ☑️  |   ✅   |       ✅      |
| Add new feature spanning multiple files          |      |   ✅   |       ✅      |
| Document new features                            |      |   ✅   |       ✅      |
| Open Linear tickets or start a pull request      |      |   ✅   |       ✅      |
| Start a new branch in GitHub from recent commits |      |   ✅   |       ✅      |
| Automatically perform tasks on your behalf       |      |   ✅   |       ✅      |
| Work on multiple tasks in the same repository    |      |       |       ✅      |
| Continue working after closing VS Code           |      |       |       ✅      |

## Use cases

Use Remote Agent to handle various aspects of your software development workflow, from simple configuration changes to feature implementations. Remote Agent is best for discreet tasks that can be completed in isolation from other work. Remote Agent supports your daily engineering tasks like:

* **Make quick edits** - Create a pull request to adjust configuration values like feature flags from FALSE to TRUE
* **Fix papercuts** - Fix small bugs or issues in the codebase that never make it to the top of your TODO list
* **Perform refactoring** - Move functions between files while maintaining coding conventions and ensuring bug-free operation
* **Explore alternatives** - Run multiple remote agents to create alternative solutions to a problem
* **Start a first draft for new features** - Start a pull request (PR) with implementing entirely new functionality straight from a GitHub Issue or Linear Ticket
* **Start tickets in Linear or Jira** - Open tickets and ask Agent to suggest a plan to address the ticket
* **Create test coverage** - Generate unit tests for your newly developed features
* **Generate documentation** - Produce comprehensive documentation for your libraries and features

## Remote Agent Clean-up

Remote Agents automatically pause after completing a request or remaining idle for a period of time. Agents that remain idle for 30 days are automatically cleaned up by the system. This cleanup process removes all files in the Remote Workspace, conversation history, and any pending diffs.

## Next steps

* [Configure Agent Integrations](/setup-augment/agent-integrations)
* [Configure other tools with MCP](/setup-augment/mcp)


# Using Augment for Slack
Source: https://docs.augmentcode.com/using-augment/slack

Chat with Augment directly in Slack to explore your codebase, get instant help, and collaborate with your team on technical problems.

## About Augment for Slack

Augment for Slack brings the power of Augment Chat to your team's Slack workspace. Mention <Command /> in any channel or start a DM with Augment to have deep codebase-aware conversations with your team. Before you can use Augment for Slack, you will need to [install the Augment Slack App](/setup-augment/install-slack-app).

<img alt="Augment for Slack" />

## Adding Augment to Channels

Mention <Command /> to add it to any public or private channel.

*Note: To protect your code, Augment excludes repository context in channels with external members.*

## Starting Conversations in Channels

Mention <Command /> anywhere in your message or thread to start a conversation. Augment will consider the entire thread's context when responding. Remove messages by adding a ❌ reaction.

## Direct Messages

While group discussions help share knowledge, you can also have private conversations with Augment. Access it by:

* Clicking the Augment logo in the top right of your Slack workspace
* Finding it under <Command /> in the Slack sidebar
* Pressing <Keyboard /> and searching for <Command />

If you don't see the Augment logo, add it to your [navigation bar](/setup-augment/install-slack-app#3-add-augment-to-the-slack-navigation-bar). *If you don't see this option, contact your workspace admin to [re-install the App](/setup-augment/install-slack-app#2-install-slack-app).*

You do not need to mention Augment in direct messages - it will respond to every message!

## Restricting where Augment can be used

Augment already avoids responding with codebase context in external channels, to protect your codebase from Slack users outside of your organization. Beyond this, you can also further restrict what channels Augment can be used in, with an allowlist. If configured, Augment will only respond in channels or DMs that are in the allowlist. To use this feature, contact us.

## Repository Context

Augment uses the default branch (typically `main`) of your linked repositories. Currently, other branches aren't accessible.

If you have multiple repositories installed, use <Command /> to choose which repository Augment should use for the current conversation. This selection applies to the specific channel or DM where you run the command, allowing you to work with different repositories in different conversations.

## Feedback

Help us improve by reacting with 👍 or 👎 to Augment's responses, or use the `Send feedback` message shortcut. We love hearing from you!


# Using Tasklist
Source: https://docs.augmentcode.com/using-augment/tasklist

Use Tasklist to break down complex problems into manageable steps, track progress, and collaborate with Agent on multi-step tasks.

## About the Tasklist?

Augment's Tasklist helps the Agent in the IDE create and refine a step-by-step plan for you to review. The Tasklist provides a structured interface for collaboration between you and the Agent, allowing you to break down complex problems into manageable, sequential steps.

<img alt="Tasklist Overview" />

## Getting started with Tasklist?

Tasklist improves agent effectiveness on long or complex tasks by:

* **Maintaining context** across different conversations by moving your Tasklist to a new chat
* **Breaking down complex problems** into manageable, sequential steps
* **Gathering progress** across threads
* **Exploring alternative solutions** to completed tasks if you need to pivot
* **Streamlining your approach** to nebulous problems by deleting irrelevant steps once the path forward is clear

Tasklist provides a structured interface for collaboration and opens up possibilities for agent-to-agent collaboration. We hypothesize that an interface such as Tasklist could be a preferred way to interact with coding agents in the future.

## Creating a New Task

### Automatic Creation

The Agent will usually create a Tasklist when it encounters a complex, multi-step problem. You can also ask the Agent to make a Tasklist for you by simply prompting "Start a Tasklist to..." then add the problem you are trying to tackle.

### Manual Creation

You can also manually create a Tasklist:

1. Switch to Tasklist using the checklist button next to Changes
2. Click the plus to add your first task
3. Alternatively, you can create a new task by typing in the gray prompt box at the bottom of the extension. Click **Add Task** from the dropdown arrow next to Send

<img alt="Creating a new task" />

## Running Tasks

To run a task, click the grey triangle (play button) next to the task. The Agent will begin executing the task and update its status as it progresses.

<img alt="Running a task" />

## Task Status Indicators

Task statuses are indicated by different colors and icons:

* **Empty circle** - Task has not yet started
* **Blue half circle** - Task is currently in progress
* **Green checkbox** - Task has been completed and is ready for review

<img alt="Task status indicators" />

## Subtasks

Augment Code automatically generates subtasks when needed. The Agent will automatically add and nest required subtasks under your initial tasks. You can edit and expand these subtasks just like any other task in the list. Likewise, you can remove subtasks you deem unnecessary.

<img alt="Subtasks example" />

## Managing Running Tasks

### Stopping a Task

You can treat any in-progress task like any prompt you might send the Agent. To stop what the Agent is doing and offer a corrective action, click the red square (stop button) and tell the Agent what you want it to do instead.

### Running All Tasks

The Agent can complete all the tasks sequentially by clicking the triangle (play button) at the top of the Tasklist.

## Reviewing Changes

You can review the changes made by the Agent after a task is completed by toggling between the Tasks and Changes view to see the diffs (differences) of the work done by the agent for each task.

<img alt="Reviewing changes in Tasks and Changes view" />

## Integration with Task Management Tools

### Jira and Linear Integration

The Tasklist is a perfect pairing with existing task management tools like Jira or Linear:

* Ask the Agent to create a Tasklist based on tickets inside Jira or Linear
* Further break down complex tickets into manageable steps
* Once your Tasklist is completed, you can ask the Agent to resolve the issue inside Jira or Linear and append the steps taken as a comment

### Standalone Usage

Don't use an issue tracker? No problem - use Tasklist to track issues you need to tackle across Threads.

## Best Practices

* **Be specific** when creating tasks to help the Agent understand exactly what needs to be done
* **Review and edit** the automatically generated subtasks to ensure they align with your goals
* **Use the stop function** to provide course corrections when the Agent is heading in the wrong direction
* **Leverage the Changes view** to review all modifications made during task execution
* **Move Tasklists** between conversations to maintain context across different chat sessions

## Next Steps

* [Learn more about Agent](/using-augment/agent)
* [Configure Agent Integrations](/setup-augment/agent-integrations)


# Install Augment for Vim and Neovim
Source: https://docs.augmentcode.com/vim/setup-augment/install-vim-neovim

Augment for Vim and Neovim gives you powerful code completions and chat capabilities integrated into your favorite code editor.

<CardGroup>
  <Card title="Get the Augment Extension" href="https://github.com/augmentcode/augment.vim" icon={<NeoVimLogo />}>
    View Augment for Vim and Neovim on GitHub
  </Card>
</CardGroup>

## About Installation

Installing <ExternalLink href="https://github.com/augmentcode/augment.vim" /> is easy and will take you less than a minute. You can install the extension manually or you can use your favorite plugin manager.

## Prerequisites

Augment for Vim and Neovim requires a compatible version of Vim or Neovim, and Node.js:

| Dependency                                                                                     | Minimum version |
| :--------------------------------------------------------------------------------------------- | :-------------- |
| [Vim](https://github.com/vim/vim?tab=readme-ov-file#installation)                              | 9.1.0           |
| [Neovim](https://github.com/neovim/neovim/tree/master?tab=readme-ov-file#install-from-package) | 0.10.0          |
| [Node.js](https://nodejs.org/en/download/package-manager/all)                                  | 22.0.0          |

## 1. Install the extension

<Tabs>
  <Tab title="Neovim">
    ### Manual Installation

    ```sh theme={null}
    git clone https://github.com/augmentcode/augment.vim.git ~/.config/nvim/pack/augment/start/augment.vim
    ```

    ### Using Lazy.nvim

    Add the following to your `init.lua` file, then run `:Lazy sync` in Neovim. See more details about using [Lazy.nvim on GitHub](https://github.com/folke/lazy.nvim).

    ```lua theme={null}
    require('lazy').setup({
      -- Your other plugins here
      'augmentcode/augment.vim',
    })
    ```
  </Tab>

  <Tab title="Vim">
    ### Manual Installation

    ```sh theme={null}
    git clone https://github.com/augmentcode/augment.vim.git ~/.vim/pack/augment/start/augment.vim
    ```

    ### Using Vim Plug

    Add the following to your `.vimrc` file, then run `:PlugInstall` in Vim. See more details about using [Vim Plug on GitHub](https://github.com/junegunn/vim-plug).

    ```vim theme={null}
    call plug#begin()

    " Your other plugins here
    Plug 'augmentcode/augment.vim'

    call plug#end()
    ```
  </Tab>
</Tabs>

## 2. Configure your workspace context

Add your project root to your workspace context by setting `g:augment_workspace_folders` in your `.vimrc` or `init.lua` file before the plugin is loaded. For example:

```vim theme={null}
" Add to your .vimrc
let g:augment_workspace_folders = ['/path/to/project']

" Add to your init.lua
vim.g.augment_workspace_folders = {'/path/to/project'}
```

Augment's Context Engine provides the best suggestions when it has access to your project's codebase and any related repositories. See more details in
[Configure additional workspace context](/vim/setup-augment/workspace-context-vim).

## 3. Sign-in to Augment

Open Vim or Neovim and sign-in to Augment with the following command:

```vim theme={null}
:Augment signin
```

<Next>
  * [Using Chat with Vim and Neovim](/vim/using-augment/vim-chat)
  * [Using Completions with Vim and Neovim](/vim/using-augment/vim-completions)
  * [Configure keyboard shortcuts](/vim/setup-augment/vim-keyboard-shortcuts)
</Next>


# Commands and shortcuts for Vim and Neovim
Source: https://docs.augmentcode.com/vim/setup-augment/vim-keyboard-shortcuts

Augment flexibly integrates with your editor to provide keyboard shortcuts for common actions. Customize your keymappings to quickly accept suggestions and chat with Augment.

## All available commands

| Command      | Action                                      |
| :----------- | :------------------------------------------ |
| <Keyboard /> | Globally enable suggestions (on by default) |
| <Keyboard /> | Globally disable suggestions                |
| <Keyboard /> | Send a chat message to Augment              |
| <Keyboard /> | Start a new chat conversation               |
| <Keyboard /> | Toggle the chat panel visibility            |
| <Keyboard /> | Start the sign in flow                      |
| <Keyboard /> | Sign out of Augment                         |
| <Keyboard /> | View the current status of the plugin       |
| <Keyboard /> | View the plugin log                         |

## Creating custom shortcuts

You can create custom shortcuts for any of the above commands by adding mappings to your `.vimrc` or `init.lua` file. For example, to create a shortcut for the :Augment chat\* commands, you can add the following mappings:

```vim theme={null}
" Send a chat message in normal and visual mode
nnoremap <leader>ac :Augment chat<CR>
vnoremap <leader>ac :Augment chat<CR>

" Start a new chat conversation
nnoremap <leader>an :Augment chat-new<CR>

" Toggle the chat panel visibility
nnoremap <leader>at :Augment chat-toggle<CR>
```

## Customizing accepting a completion suggestion

By default <Keyboard /> is used to accept a suggestion. If you want to use a key other than <Keyboard /> to accept a suggestion, create a mapping that calls `augment#Accept()`. The function takes an optional arugment used to specify the fallback text to insert if no suggestion is available.

```vim theme={null}
" Use Ctrl-Y to accept a suggestion
inoremap <c-y> <cmd>call augment#Accept()<cr>

" Use enter to accept a suggestion, falling back to a newline if no suggestion
" is available
inoremap <cr> <cmd>call augment#Accept("\n")<cr>
```

You can disable the default <Keyboard /> mapping by setting `g:augment_disable_tab_mapping = v:true` before the plugin is loaded.


# Add context to your workspace
Source: https://docs.augmentcode.com/vim/setup-augment/workspace-context-vim

You can add additional context to your workspace–such as additional repositories and folders–to give Augment a full view of your system.

<Availability />

## About Workspace Context

Augment is powered by its deep understanding of your code. You'll need to configure your project's source in your workspace context to get full codebase understanding in your chats and suggestions.

Sometimes important parts of your system exist outside of the current project. For example, you may have seperate frontend and backend repositories or have many services across multiple repositories. Adding additional codebases to your workspace context will improve the code suggestions and chat responses from Augment.

## Add context to your workspace

<Note>
  Be sure to set `g:augment_workspace_folders` before the Augment plugin is loaded.
</Note>

To add context to your workspace, in your `.vimrc` set `g:augment_workspace_folders` to a list of paths to the folders you want to add to your workspace context. For example:

```vim theme={null}
let g:augment_workspace_folders = ['/path/to/folder', '~/path/to/another/folder']
```

You may want to ignore specific folders, like `node_modules`, see [Ignoring files with .augmentignore](/setup-augment/workspace-indexing#ignoring-files-with-augmentignore) for more details.

After adding a workspace folder and restarting Vim, the output of the <Keyboard /> command will include the syncing progress for the added folder.


# Index your workspace
Source: https://docs.augmentcode.com/vim/setup-augment/workspace-indexing

When your workspace is indexed, Augment can provide tailored code suggestions and answers based on your unique codebase, best practices, coding patterns, and preferences. You can always control what files are indexed.

## About indexing your workspace

When you open a workspace with Augment enabled, your codebase will be automatically uploaded to Augment's secure cloud. You can control what files get indexed using `.gitignore` and `.augmentignore` files. Indexing usually takes less than a minute but can take longer depending on the size of your codebase.

## Security and privacy

Augment stores your code securely and privately to enable our powerful context engine. We ensure code privacy through a proof-of-possession API and maintain strict internal data minimization principles. [Read more about our security](https://www.augmentcode.com/security).

## What gets indexed

Augment will index all the files in your workspace, except for the files that match patterns in your `.gitignore` file and the `.augmentignore` file.

## Ignoring files with .augmentignore

The `.augmentignore` file is a list of file patterns that Augment will ignore when indexing your workspace. Create an `.augmentignore` file in the root of your workspace. You can use any glob pattern that is supported by the [gitignore](https://git-scm.com/docs/gitignore) file.

## Including files that are .gitignored

If you have a file or directory in your `.gitignore` that you want to indexed, you can add it to your `.augmentignore` file using the `!` prefix.

For example, you may want your `node_modules` indexed to provide Augment with context about the dependencies in their project, but it is typically included in their `.gitignore`. Add `!node_modules` to your `.augmentignore` file.

<CodeGroup>
  ```bash .augmentignore theme={null}
  # Include .gitignore excluded files with ! prefix
  !node_modules

  # Exclude other files with .gitignore syntax
  data/test.json
  ```

  ```bash .gitignore theme={null}
  # Exclude dependencies
  node_modules

  # Exclude secrets
  .env

  # Exclude build artifacts
  out
  build
  ```
</CodeGroup>


# Chat
Source: https://docs.augmentcode.com/vim/using-augment/vim-chat

Use Chat to explore your codebase, quickly get up to speed on unfamiliar code, and get help working through a technical problem.

## Using chat

Chat is a new way to work with your codebase using natural language. Use Chat to explore your codebase, quickly get up to speed on unfamiliar code, and get help working through a technical problem.

| Command      | Action                           |
| :----------- | :------------------------------- |
| <Keyboard /> | Send a chat message to Augment   |
| <Keyboard /> | Start a new chat conversation    |
| <Keyboard /> | Toggle the chat panel visibility |

### Sending a message

You can send a message to Chat using the <Keyboard /> command. You can send your message as an optional argument to the command or enter it into the command-line when prompted. Each new message will continue the current conversation which will be used as context for your next message.

**Focusing on selected text**

If you have text selected in `visual mode`, Augment will automatically include it in your message. This is useful for asking questions about specific code or requesting changes to the selected code.

### Starting a new conversation

You can start a new conversation by using the <Keyboard /> command.

<Next>
  * [Using Completions](/vim/using-augment/vim-completions)
  * [Configure keyboard shortcuts](/vim/setup-augment/vim-keyboard-shortcuts)
</Next>


# Completions
Source: https://docs.augmentcode.com/vim/using-augment/vim-completions

Use code completions to get more done. Augment’s radical context awareness means more relevant suggestions, fewer hallucinations, and less time hunting down documentation.

## Using completions

Augment’s code completions integrates with Vim and Neovim to give you autocomplete-like suggestions as you type. Completions are enable by default and you can use <Keyboard /> to accept a suggestion.

| Command      | Action                                      |
| :----------- | :------------------------------------------ |
| <Keyboard /> | Accept the current suggestion               |
| <Keyboard /> | Globally enable suggestions (on by default) |
| <Keyboard /> | Globally disable suggestions                |

### Customizing accepting a suggestion

If you want to use a key other than <Keyboard /> to accept a suggestion, create a mapping that calls `augment#Accept()`. The function takes an optional arugment used to specify the fallback text to insert if no suggestion is available.

```vim theme={null}
" Use Ctrl-Y to accept a suggestion
inoremap <c-y> <cmd>call augment#Accept()<cr>

" Use enter to accept a suggestion, falling back to a newline if no suggestion
" is available
inoremap <cr> <cmd>call augment#Accept("\n")<cr>
```

You can disable the default <Keyboard /> mapping by setting `g:augment_disable_tab_mapping = v:true` before the plugin is loaded.

<Next>
  * [Using Chat](/vim/using-augment/vim-chat)
  * [Configure keyboard shortcuts](/vim/setup-augment/vim-keyboard-shortcuts)
</Next>