Gemini CLI

https://geminicli.com/docs
Admin
Gemini CLI is a command-line interface tool that brings Google's Gemini AI models to your terminal...
Tokens:116,525
Snippets:1,773
Trust Score:7.8
Update:2 months ago
Show doc for...
Tokens:
Raw
### Automated Local Model Routing Setup

Source: https://geminicli.com/docs/core/gemma-setup

Run this command to perform a full installation, including downloading the binary, model, settings, and starting the server.

```bash
gemini gemma setup
```

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

### Setup Without Auto-Start

Source: https://geminicli.com/docs/core/gemma-setup

Use the `--no-start` flag to skip automatically starting the server after the installation is complete.

```bash
gemini gemma setup --no-start
```

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

### Setup and Verification Commands

Source: https://geminicli.com/docs/release-confidence

Commands used to prepare the environment and verify the installation during the CUJ checklist.

```bash
npm uninstall -g @google/gemini-cli
```

```bash
npm cache clean --force
```

```bash
npm install -g @google/gemini-cli@preview
```

```bash
gemini --version
```

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

### Start LiteRT-LM Runtime (Example)

Source: https://geminicli.com/docs/core/local-model-routing

Start the LiteRT-LM runtime on MacOS, specifying the port for the Gemma model. This example uses port 9379.

```bash
./lit.macos_arm64 serve --port=9379 --verbose
```

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

### Install dependencies

Source: https://geminicli.com/docs/contributing

Install all required project dependencies defined in package.json.

```bash
npm install
```

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

### Test LiteRT-LM Runtime (Windows)

Source: https://geminicli.com/docs/core/local-model-routing

Verify the LiteRT-LM runtime is installed and functional on Windows by attempting to start the server in verbose mode.

```bash
.\lit.windows_x86_64.exe serve --verbose
```

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

### Install an extension from GitHub

Source: https://geminicli.com/docs/extensions

Install a new extension by providing the URL to its GitHub repository.

```bash
gemini extensions install https://github.com/gemini-cli-extensions/workspace
```

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

### Test LiteRT-LM Runtime (Linux)

Source: https://geminicli.com/docs/core/local-model-routing

Verify the LiteRT-LM runtime is installed and functional on Linux by attempting to start the server in verbose mode.

```bash
./lit.linux_x86_64 serve --verbose
```

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

### Install a Skill from a Remote URL

Source: https://geminicli.com/docs/cli/using-agent-skills

Installs a skill from a remote repository. By default, it installs to your user profile. Use `--scope workspace` to install it only for the current project.

```bash
gemini skills install https://github.com/user/my-awesome-skill
```

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

### Install Extension Dependencies

Source: https://geminicli.com/docs/extensions/writing-extensions

Before linking your extension, navigate to the extension's directory and install its Node.js dependencies using `npm install`.

```bash
cd my-first-extension
npm install
```

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

### Test LiteRT-LM Runtime (MacOS)

Source: https://geminicli.com/docs/core/local-model-routing

Verify the LiteRT-LM runtime is installed and functional on MacOS by attempting to start the server in verbose mode.

```bash
./lit.macos_arm64 serve --verbose
```

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

### Install an Extension

Source: https://geminicli.com/docs/extensions/reference

Installs an extension from a GitHub repository URL or a local file path. Requires git to be installed for GitHub sources. Options include specifying a git ref, enabling auto-updates, installing pre-release versions, skipping confirmation, and skipping settings configuration.

```bash
gemini extensions install <source> [--ref <ref>] [--auto-update] [--pre-release] [--consent] [--skip-settings]
```

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

### Example GEMINI.md with imports

Source: https://geminicli.com/docs/cli/gemini-md

Demonstrates how to modularize context files by importing content from other files using the @ syntax.

```markdown
# Main GEMINI.md file

This is the main content.

@./components/instructions.md

More content here.

@../shared/style-guide.md
```

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

### Start the CLI

Source: https://geminicli.com/docs/contributing

Launch the Gemini CLI from the source code after building.

```bash
npm start
```

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

### Install Gemini CLI Preview

Source: https://geminicli.com/docs/changelogs/preview

Use this command to install the preview version of the Gemini CLI globally via npm.

```bash
npm install -g @google/gemini-cli@preview
```

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

### Install Arize extension

Source: https://geminicli.com/docs/changelogs

Installs the Arize AI application instrumentation extension.

```bash
gemini extensions install https://github.com/Arize-ai/arize-tracing-assistant
```

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

### Install a Skill

Source: https://geminicli.com/docs/cli/skills

Install a skill from a Git repository or local directory. Use the `--consent` flag to bypass the security confirmation prompt.

```bash
gemini skills install https://github.com/user/repo.git --consent
```

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

### Install and run React DevTools

Source: https://geminicli.com/docs/contributing

Commands to install or execute the React DevTools for UI debugging.

```bash
npm install -g react-devtools@6
react-devtools
```

```bash
npx react-devtools@6
```

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

### Create a New Skill with skill-creator

Source: https://geminicli.com/docs/cli/tutorials/skills-getting-started

Use the `skill-creator` to automatically generate the necessary files and directory structure for a new skill. This is a convenient way to start developing a skill without manual setup.

```bash
gemini skills install <url-or-path>
```

```bash
gemini skills link <path>
```

```bash
gemini skills uninstall <name>
```

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

### Install skill from source

Source: https://geminicli.com/docs/cli/cli-reference

Installs a new agent skill. The source can be a Git repository URL, a local file path, or a directory path.

```bash
gemini skills install https://github.com/u/repo
```

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

### Install extension versions

Source: https://geminicli.com/docs/extensions/best-practices

Install specific versions or branches of an extension using the CLI.

```bash
# Install the stable version (default branch)
gemini extensions install github.com/user/repo

# Install the development version
gemini extensions install github.com/user/repo --ref dev
```

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

### Install Gemini CLI (Stable)

Source: https://geminicli.com/docs/get-started/installation

Installs the latest stable release of the Gemini CLI. This is the recommended channel for most users. Omitting the tag also installs the latest stable release.

```bash
# Both commands install the latest stable release.
npm install -g @google/gemini-cli
npm install -g @google/gemini-cli@latest
```

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

### Example GEMINI.md file content

Source: https://geminicli.com/docs/cli/gemini-md

A sample configuration file demonstrating project-specific instructions and coding style guidelines.

```markdown
# Project: My TypeScript Library

## General Instructions

- When you generate new TypeScript code, follow the existing coding style.
- Ensure all new functions and classes have JSDoc comments.
- Prefer functional programming paradigms where appropriate.

## Coding Style

- Use 2 spaces for indentation.
- Prefix interface names with `I` (for example, `IUserService`).
- Always use strict equality (`===` and `!==`).
```

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

### Add an stdio MCP server

Source: https://geminicli.com/docs/tools/mcp-server

Examples for configuring local stdio-based MCP servers with environment variables and arguments.

```bash
# Basic syntax
gemini mcp add [options] <name> <command> [args...]

# Example: Adding a local server
gemini mcp add -e API_KEY=123 -e DEBUG=true my-stdio-server /path/to/server arg1 arg2 arg3

# Example: Adding a local python server
gemini mcp add python-server python server.py -- --server-arg my-value
```

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

### Install Chronosphere extension

Source: https://geminicli.com/docs/changelogs

Installs the Chronosphere extension for retrieving logs, metrics, and traces.

```bash
gemini extensions install https://github.com/chronosphereio/chronosphere-mcp
```

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

### Install Gemini CLI Extensions

Source: https://geminicli.com/docs/changelogs

Commands to install specific partner extensions for the Gemini CLI.

```bash
gemini extensions install https://github.com/huggingface/hf-mcp-server
```

```bash
gemini extensions install https://github.com/mondaycom/mcp
```

```bash
gemini extensions install https://github.com/gemini-cli-extensions/datacommons
```

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

### Configure settings.json

Source: https://geminicli.com/docs/reference/configuration

Example of the nested configuration structure supported as of v0.3.0.

```json
{
  "general": {
    "vimMode": true,
    "preferredEditor": "code",
    "sessionRetention": {
      "enabled": true,
      "maxAge": "30d",
      "maxCount": 100
    }
  },
  "ui": {
    "theme": "GitHub",
    "hideBanner": true,
    "hideTips": false,
    "customWittyPhrases": [
      "You forget a thousand things every day. Make sure this is one of ’em",
      "Connecting to AGI"
    ]
  },
  "tools": {
    "sandbox": "docker",
    "discoveryCommand": "bin/get_tools",
    "callCommand": "bin/call_tool",
    "exclude": ["write_file"]
  },
  "mcpServers": {
    "mainServer": {
      "command": "bin/mcp_server.py"
    },
    "anotherServer": {
      "command": "node",
      "args": ["mcp_server.js", "--verbose"]
    }
  },
  "telemetry": {
    "enabled": true,
    "target": "local",
    "otlpEndpoint": "http://localhost:4317",
    "logPrompts": true
  },
  "privacy": {
    "usageStatisticsEnabled": true
  },
  "model": {
    "name": "gemini-1.5-pro-latest",
    "maxSessionTurns": 10,
    "summarizeToolOutput": {
      "run_shell_command": {
        "tokenBudget": 100
      }
    }
  },
  "context": {
    "fileName": ["CONTEXT.md", "GEMINI.md"],
    "includeDirectories": ["path/to/dir1", "~/path/to/dir2", "../path/to/dir3"],
    "loadFromIncludeDirectories": true,
    "fileFiltering": {
      "respectGitIgnore": false
    }
  },
  "advanced": {
    "excludedEnvVars": ["DEBUG", "DEBUG_MODE", "NODE_ENV"]
  }
}
```

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

### Custom Port Setup

Source: https://geminicli.com/docs/core/gemma-setup

Use the `--port` flag to specify a custom port for the local inference server during setup.

```bash
gemini gemma setup --port 8080
```

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

### Example Project Context File (GEMINI.md)

Source: https://geminicli.com/docs/reference/configuration

A template for defining project-wide coding standards, instructions, and component-specific notes in Markdown format.

```markdown
# Project: My Awesome TypeScript Library

## General Instructions:

- When generating new TypeScript code, follow the existing coding style.
- Ensure all new functions and classes have JSDoc comments.
- Prefer functional programming paradigms where appropriate.
- All code should be compatible with TypeScript 5.0 and Node.js 20+.

## Coding Style:

- Use 2 spaces for indentation.
- Interface names should be prefixed with `I` (for example, `IUserService`).
- Private class members should be prefixed with `_`.
- Always use strict equality (`===` and `!==`).

## Specific Component: `src/api/client.ts`

- This file handles all outbound API requests.
- When adding new API call functions, ensure they include robust error handling
  and logging.
- Use the existing `fetchWithRetry` utility for all GET requests.

## Regarding Dependencies:

- Avoid introducing new external dependencies unless absolutely necessary.
- If a new dependency is required, state the reason.
```

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

### Force Re-download

Source: https://geminicli.com/docs/core/gemma-setup

Use the `--force` flag to re-download all components, including the binary and model, during setup.

```bash
gemini gemma setup --force
```

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

### Install Gemini CLI

Source: https://geminicli.com/docs/changelogs/latest

Use this command to install the latest stable version of the Gemini CLI globally via npm.

```bash
npm install -g @google/gemini-cli
```

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

### Add an HTTP MCP server

Source: https://geminicli.com/docs/tools/mcp-server

Examples for configuring HTTP-based MCP servers, including those requiring authentication headers.

```bash
# Basic syntax
gemini mcp add --transport http <name> <url>

# Example: Adding an HTTP server
gemini mcp add --transport http http-server https://api.example.com/mcp/

# Example: Adding an HTTP server with an authentication header
gemini mcp add --transport http --header "Authorization: Bearer abc123" secure-http https://api.example.com/mcp/
```

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

### Install Gemini CLI Companion extension via CLI

Source: https://geminicli.com/docs/ide-integration

Use this command to automatically detect and install the appropriate extension for your IDE.

```text
/ide install
```

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

### Circular Import Detection Example

Source: https://geminicli.com/docs/reference/memport

Provides an example of two files that import each other, demonstrating the circular import detection mechanism.

```markdown
# file-a.md

@./file-b.md
```

```markdown
# file-b.md

@./file-a.md <!-- This will be detected and prevented -->
```

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

### Start Google Cloud telemetry collector

Source: https://geminicli.com/docs/local-development

Command to start the local OTel collector configured to forward data to Google Cloud.

```bash
npm run telemetry -- --target=gcp
```

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

### Enterprise settings.json configuration

Source: https://geminicli.com/docs/cli/enterprise

A complete configuration file example for securing and customizing the Gemini CLI environment.

```json
{
  "tools": {
    "sandbox": "docker",
    "core": [
      "ReadFileTool",
      "GlobTool",
      "ShellTool(ls)",
      "ShellTool(cat)",
      "ShellTool(grep)"
    ]
  },
  "mcp": {
    "allowed": ["corp-tools"]
  },
  "mcpServers": {
    "corp-tools": {
      "command": "/opt/gemini-tools/start.sh",
      "timeout": 5000
    }
  },
  "telemetry": {
    "enabled": true,
    "target": "gcp",
    "otlpEndpoint": "https://telemetry-prod.example.com:4317",
    "logPrompts": false
  },
  "advanced": {
    "bugCommand": {
      "urlTemplate": "https://servicedesk.example.com/new-ticket?title={title}&details={info}"
    }
  },
  "privacy": {
    "usageStatisticsEnabled": false
  }
}
```

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

### Add an SSE MCP server

Source: https://geminicli.com/docs/tools/mcp-server

Examples for configuring SSE-based MCP servers, including those requiring authentication headers.

```bash
# Basic syntax
gemini mcp add --transport sse <name> <url>

# Example: Adding an SSE server
gemini mcp add --transport sse sse-server https://api.example.com/sse/

# Example: Adding an SSE server with an authentication header
gemini mcp add --transport sse --header "Authorization: Bearer abc123" secure-sse https://api.example.com/sse/
```

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

### Install Google Workspace Extension

Source: https://geminicli.com/docs/changelogs

Use this command to integrate Gemini CLI with Google Workspace data.

```bash
gemini extensions install https://github.com/gemini-cli-extensions/workspace
```

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

### Install Extension from Git Repository with Specific Ref

Source: https://geminicli.com/docs/extensions/releasing

Users can install extensions from a Git repository and optionally specify a branch, tag, or commit using the --ref argument.

```bash
gemini extensions install <your-repo-uri> --ref=stable
```

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

### Configure System Prompt Override

Source: https://geminicli.com/docs/cli/system-prompt

Examples for enabling, persisting, or customizing the system prompt via environment variables.

```bash
GEMINI_SYSTEM_MD=1 gemini
```

```bash
GEMINI_SYSTEM_MD=1
```

```bash
GEMINI_SYSTEM_MD=~/prompts/system.md gemini
```

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

### Start CLI in development mode

Source: https://geminicli.com/docs/contributing

Launch the CLI with development flags for React DevTools integration.

```bash
DEV=true npm start
```

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

### Implement Initialization Hook

Source: https://geminicli.com/docs/hooks/writing-hooks

A simple script to initialize resources and provide a system message upon session start.

```javascript
#!/usr/bin/env node
// Initialize DB or resources
console.error('Initializing assistant...');

// Output to user
console.log(
  JSON.stringify({
    systemMessage: '🧠 Smart Assistant Loaded',
  }),
);
```

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

### Enable sandboxing

Source: https://geminicli.com/docs/cli/tutorials/shell-commands

Start the CLI with the --sandbox flag to run commands inside a secure Docker container.

```shell
gemini --sandbox
```

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

### Install Latest Gemini CLI

Source: https://geminicli.com/docs/get-started/gemini-3

Upgrade your Gemini CLI to the latest version to get started with Gemini 3. This command installs the most recent stable release.

```bash
npm install -g @google/gemini-cli@latest
```

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

### Example of an insecure configuration

Source: https://geminicli.com/docs/cli/enterprise

Omitting the mcp.allowed setting allows users to define and run their own unauthorized MCP servers.

```json
{
  "mcpServers": {
    "corp-data-api": {
      "command": "/usr/local/bin/start-corp-api.sh"
    }
  }
}
```

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

### List extensions via interactive command

Source: https://geminicli.com/docs/extensions

Use the interactive command interface to view installed extensions and their status.

```bash
/extensions list
```

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

### Initialize project dependencies and build

Source: https://geminicli.com/docs/resources/troubleshooting

Standard commands to resolve missing dependencies and compile the project.

```bash
npm install
npm run build
npm run start
```

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

### Basic GEMINI.md Import Example

Source: https://geminicli.com/docs/reference/memport

Illustrates a simple import of a 'get-started.md' file and a 'features/overview.md' file into a main GEMINI.md file.

```markdown
# My GEMINI.md

Welcome to my project!

@./get-started.md

## Features

@./features/overview.md
```

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

### Build the project

Source: https://geminicli.com/docs/contributing

Build the CLI utility and sandbox container from the root directory.

```bash
npm run build:all
```

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

### Define modelConfigs structure

Source: https://geminicli.com/docs/reference/configuration

Example configuration showing model extensions, thinking configurations, and specific model assignments.

```json
"extends": "gemini-3-flash-base",
        "modelConfig": {}
      },
      "context-snapshotter": {
        "extends": "gemini-3-flash-base",
        "modelConfig": {
          "generateContentConfig": {
            "thinkingConfig": {
              "thinkingLevel": "HIGH"
            },
            "temperature": 1,
            "topP": 0.95,
            "topK": 64
          }
        }
      },
      "chat-compression-3-pro": {
        "modelConfig": {
          "model": "gemini-3-pro-preview"
        }
      },
      "chat-compression-3-flash": {
        "modelConfig": {
          "model": "gemini-3-flash-preview"
        }
      },
      "chat-compression-3.1-flash-lite": {
        "modelConfig": {
          "model": "gemini-3.1-flash-lite"
        }
      },
      "chat-compression-2.5-pro": {
        "modelConfig": {
          "model": "gemini-2.5-pro"
        }
      },
      "chat-compression-2.5-flash": {
        "modelConfig": {
          "model": "gemini-2.5-flash"
        }
      },
      "chat-compression-2.5-flash-lite": {
        "modelConfig": {
          "model": "gemini-2.5-flash-lite"
        }
      },
      "chat-compression-default": {
        "modelConfig": {
          "model": "gemini-3-pro-preview"
        }
      },
      "agent-history-provider-summarizer": {
        "modelConfig": {
          "model": "gemini-3-flash-preview"
        }
      }
    }
```

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

### Perform a manual local build and publish

Source: https://geminicli.com/docs/contributing

Use these commands to clean, install dependencies, authenticate, and publish the project workspaces manually.

```bash
npm run clean
npm install
npm run auth
npm run prerelease:dev
npm publish --workspaces
```

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

### Example HTTPS Proxy Script for Gemini CLI

Source: https://geminicli.com/docs/examples/proxy-script

This Node.js script acts as a proxy, listening on a specified port and only permitting HTTPS connections to predefined domains. It's intended for use with the `GEMINI_SANDBOX_PROXY_COMMAND` environment variable to control network access within the Gemini sandbox. Ensure Node.js is installed to run this script.

```javascript
#!/usr/bin/env node

/**
 * @license
 * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

// Example proxy server that listens on :::8877 and only allows HTTPS connections to example.com.
// Set `GEMINI_SANDBOX_PROXY_COMMAND=scripts/example-proxy.js` to run proxy alongside sandbox
// Test via `curl https://example.com` inside sandbox (in shell mode or via shell tool)

import http from 'node:http';
import net from 'node:net';
import { URL } from 'node:url';
import console from 'node:console';

const PROXY_PORT = 8877;
const ALLOWED_DOMAINS = ['example.com', 'googleapis.com'];
const ALLOWED_PORT = '443';

const server = http.createServer((req, res) => {
  // Deny all requests other than CONNECT for HTTPS
  console.log(
    `[PROXY] Denying non-CONNECT request for: ${req.method} ${req.url}`,
  );
  res.writeHead(405, { 'Content-Type': 'text/plain' });
  res.end('Method Not Allowed');
});

server.on('connect', (req, clientSocket, head) => {
  // req.url will be in the format "hostname:port" for a CONNECT request.
  const { port, hostname } = new URL(`http://${req.url}`);

  console.log(`[PROXY] Intercepted CONNECT request for: ${hostname}:${port}`);

  if (
    ALLOWED_DOMAINS.some(
      (domain) => hostname == domain || hostname.endsWith(`.${domain}`),
    ) &&
    port === ALLOWED_PORT
  ) {
    console.log(`[PROXY] Allowing connection to ${hostname}:${port}`);

    // Establish a TCP connection to the original destination.
    const serverSocket = net.connect(port, hostname, () => {
      clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
      // Create a tunnel by piping data between the client and the destination server.
      serverSocket.write(head);
      serverSocket.pipe(clientSocket);
      clientSocket.pipe(serverSocket);
    });

    serverSocket.on('error', (err) => {
      console.error(`[PROXY] Error connecting to destination: ${err.message}`);
      clientSocket.end(`HTTP/1.1 502 Bad Gateway\r\n\r\n`);
    });
  } else {
    console.log(`[PROXY] Denying connection to ${hostname}:${port}`);
    clientSocket.end('HTTP/1.1 403 Forbidden\r\n\r\n');
  }

  clientSocket.on('error', (err) => {
    // This can happen if the client hangs up.
    console.error(`[PROXY] Client socket error: ${err.message}`);
  });
});

server.listen(PROXY_PORT, () => {
  const address = server.address();
  console.log(`[PROXY] Proxy listening on ${address.address}:${address.port}`);
  console.log(
    `[PROXY] Allowing HTTPS connections to domains: ${ALLOWED_DOMAINS.join(', ')}`,
  );
});

```

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

### Define Model Configuration Aliases

Source: https://geminicli.com/docs/reference/configuration

Example structure for defining named model presets using the aliases object, supporting inheritance via the extends property.

```json
{
  "base": {
    "modelConfig": {
      "generateContentConfig": {
        "temperature": 0,
        "topP": 1
      }
    }
  },
  "chat-base": {
    "extends": "base",
    "modelConfig": {
      "generateContentConfig": {
        "thinkingConfig": {
          "includeThoughts": true
        },
        "temperature": 1,
        "topP": 0.95,
        "topK": 64
      }
    }
  },
  "chat-base-2.5": {
    "extends": "chat-base",
    "modelConfig": {
      "generateContentConfig": {
        "thinkingConfig": {
          "thinkingBudget": 8192
        }
      }
    }
  },
  "chat-base-3": {
    "extends": "chat-base",
    "modelConfig": {
      "generateContentConfig": {
        "thinkingConfig": {
          "thinkingLevel": "HIGH"
        }
      }
    }
  }
}
```

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

### Enterprise Configuration Merging Example

Source: https://geminicli.com/docs/cli/enterprise

Demonstrates how settings from system defaults, user files, workspace files, and system overrides are merged into a final configuration.

```json
{
  "ui": {
    "theme": "default-corporate-theme"
  },
  "context": {
    "includeDirectories": ["/etc/gemini-cli/common-context"]
  }
}
```

```json
{
  "ui": {
    "theme": "user-preferred-dark-theme"
  },
  "mcpServers": {
    "corp-server": {
      "command": "/usr/local/bin/corp-server-dev"
    },
    "user-tool": {
      "command": "npm start --prefix ~/tools/my-tool"
    }
  },
  "context": {
    "includeDirectories": ["~/gemini-context"]
  }
}
```

```json
{
  "ui": {
    "theme": "project-specific-light-theme"
  },
  "mcpServers": {
    "project-tool": {
      "command": "npm start"
    }
  },
  "context": {
    "includeDirectories": ["./project-context"]
  }
}
```

```json
{
  "ui": {
    "theme": "system-enforced-theme"
  },
  "mcpServers": {
    "corp-server": {
      "command": "/usr/local/bin/corp-server-prod"
    }
  },
  "context": {
    "includeDirectories": ["/etc/gemini-cli/global-context"]
  }
}
```

```json
{
  "ui": {
    "theme": "system-enforced-theme"
  },
  "mcpServers": {
    "corp-server": {
      "command": "/usr/local/bin/corp-server-prod"
    },
    "user-tool": {
      "command": "npm start --prefix ~/tools/my-tool"
    },
    "project-tool": {
      "command": "npm start"
    }
  },
  "context": {
    "includeDirectories": [
      "/etc/gemini-cli/common-context",
      "~/gemini-context",
      "./project-context",
      "/etc/gemini-cli/global-context"
    ]
  }
}
```

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

### Define Skill Metadata and Instructions (SKILL.md)

Source: https://geminicli.com/docs/cli/creating-skills

Create a SKILL.md file with YAML frontmatter for skill name and description, followed by markdown instructions for the agent.

```markdown
---
name: code-reviewer
description:
  Expertise in reviewing code changes for correctness, security, and style. Use
  when the user asks to "review" their code or a PR.
---

# Code Reviewer Instructions

You act as a senior software engineer specialized in code quality. When this
skill is active, you MUST:

1.  **Analyze**: Review the provided code for logical errors, security
    vulnerabilities, and style violations.
2.  **Review**: Use the bundled `scripts/review.js` utility to perform an
    automated check.
3.  **Feedback**: Provide constructive feedback, clearly distinguishing between
    critical issues and minor improvements.
```

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

### Verify Gemini CLI Installation

Source: https://geminicli.com/docs/cli/sandbox

Check the installed version of the Gemini CLI.

```bash
gemini --version
```

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

### Install Gemini CLI with Anaconda

Source: https://geminicli.com/docs/get-started/installation

Install Gemini CLI within a new Anaconda environment. This is useful for restricted environments. It involves creating and activating an environment, then installing the CLI via npm.

```bash
# Create and activate a new environment
conda create -y -n gemini_env -c conda-forge nodejs
conda activate gemini_env

# Install Gemini CLI globally via npm (inside the environment)
npm install -g @google/gemini-cli
```

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

### Install Transmit extension

Source: https://geminicli.com/docs/changelogs

Installs the Transmit extension for authentication and identity workflow management.

```bash
gemini extensions install https://github.com/TransmitSecurity/transmit-security-journey-builder
```

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

### Create Project Context File (GEMINI.md)

Source: https://geminicli.com/docs/cli/tutorials/memory-management

Define project-wide rules and instructions in a GEMINI.md file to automatically guide the Gemini CLI's behavior in every conversation.

```markdown
# Project Instructions

- **Framework:** We use React with Vite.
- **Styling:** Use Tailwind CSS for all styling. Do not write custom CSS.
- **Testing:** All new components must include a Vitest unit test.
- **Tone:** Be concise. Don't explain basic React concepts.
```

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

### Install Redis Extension

Source: https://geminicli.com/docs/changelogs

Use this command to install the Redis MCP extension for data management.

```bash
gemini extensions install https://github.com/redis/mcp-redis
```

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

### Initialize and Enable LXC Sandboxing

Source: https://geminicli.com/docs/cli/sandbox

Commands to initialize the LXD environment, launch a container, and configure the CLI to use it for sandboxed execution.

```bash
# Initialize LXD (first time only)
lxd init --auto

# Create and start an Ubuntu container
lxc launch ubuntu:24.04 gemini-sandbox

# Enable LXC sandboxing
export GEMINI_SANDBOX=lxc
gemini -p "build the project"
```

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

### Initialize a New Skill

Source: https://geminicli.com/docs/cli/creating-skills

Use this script to initialize a new skill, specifying its name and directory. This is the first step in creating a new skill.

```bash
node scripts/init_skill.cjs <name> --path <dir>
```

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

### Validate release installation

Source: https://geminicli.com/docs/releases

Commands to verify that the package is correctly installed and accessible via npx.

```bash
npx -y @google/gemini-cli@latest --version
```

```bash
npx -y @google/gemini-cli@<release tag> --version
```

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

### Install Anomalo Extension

Source: https://geminicli.com/docs/changelogs

Use this command to install the Anomalo extension for data warehouse metadata querying.

```bash
gemini extensions install https://github.com/datagravity-ai/anomalo-gemini-extension
```

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

### Install Eleven Labs Extension

Source: https://geminicli.com/docs/changelogs

Use this command to install the Eleven Labs MCP extension for audio track management.

```bash
gemini extensions install https://github.com/elevenlabs/elevenlabs-mcp
```

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

### Start Genkit telemetry server

Source: https://geminicli.com/docs/local-development

Command to initialize the Genkit telemetry server for viewing traces in the Genkit Developer UI.

```bash
npm run telemetry -- --target=genkit
```

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

### Install Gemini CLI with MacPorts

Source: https://geminicli.com/docs/get-started/installation

Install the Gemini CLI globally using MacPorts. This method is specific to macOS users.

```bash
sudo port install gemini-cli
```

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

### Build the project

Source: https://geminicli.com/docs/contributing

Compile TypeScript and prepare packages for execution.

```bash
npm run build
```

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

### Start Jaeger telemetry collector

Source: https://geminicli.com/docs/local-development

Command to download and start the Jaeger UI and OTel collector for local trace visualization.

```bash
npm run telemetry -- --target=local
```

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

### Install or update Gemini CLI globally

Source: https://geminicli.com/docs/resources/troubleshooting

Commands used for global installation or updates that may trigger informational deprecation warnings.

```bash
npm install -g @google/gemini-cli
npm update -g @google/gemini-cli
```

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

### Create Skill Directory Structure (macOS/Linux)

Source: https://geminicli.com/docs/cli/creating-skills

Use mkdir -p to create the necessary directories for a skill, including the scripts subdirectory.

```bash
mkdir -p .gemini/skills/code-reviewer/scripts
```

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

### Install Gemini CLI with Homebrew

Source: https://geminicli.com/docs/get-started/installation

Install the Gemini CLI globally using Homebrew. This method is suitable for macOS and Linux users.

```bash
brew install gemini-cli
```
Tokens:
Raw