Gemini-CLI

https://github.com/zibri/gemini-cli
Admin
Gemini-CLI is a powerful, portable, and feature-rich command-line client for the Google Gemini API,...
Tokens:8,293
Snippets:88
Trust Score:9.2
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Prerequisites on openSUSE/Tumbleweed

Source: https://github.com/zibri/gemini-cli/blob/main/README.md

Installs necessary build tools and development libraries (cURL, zlib, readline) for gemini-cli on openSUSE systems.

```bash
sudo zypper refresh
sudo zypper install gcc make libcurl-devel readline-devel zlib-devel
```

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

### Install Prerequisites on Debian/Ubuntu

Source: https://github.com/zibri/gemini-cli/blob/main/README.md

Installs necessary build tools and development libraries (cURL, zlib, readline) for gemini-cli on Debian-based systems.

```bash
sudo apt-get update
sudo apt-get install build-essential libcurl4-openssl-dev libreadline-dev zlib1g-dev
```

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

### gemini-cli Configuration File Example

Source: https://github.com/zibri/gemini-cli/blob/main/README.md

An example JSON configuration file for gemini-cli, specifying API keys, origins, model, proxy, temperature, and other advanced settings.

```json
{
  "api_keys": [
    "your_first_api_key",
    "your_second_api_key"
  ],
  "origins": [
    "https://your-allowed-origin.com",
    "default"
  ],
  "model": "gemini-2.5-pro",
  "proxy": "http://localhost:8080",
  "temperature": 0.75,
  "seed": 42,
  "system_prompt": "You are a helpful and concise assistant.",
  "google_grounding": true,
  "url_context": true,
  "max_output_tokens": 8192,
  "top_k": 40,
  "top_p": 0.95
}
```

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

### Install Prerequisites on macOS (Homebrew)

Source: https://github.com/zibri/gemini-cli/blob/main/README.md

Installs cURL, readline, and zlib using Homebrew for gemini-cli compilation on macOS. Linker flags might be needed.

```bash
brew install curl readline zlib
# You may need to provide linker flags if they aren't found automatically
```

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

### Install Prerequisites on Fedora/CentOS/RHEL

Source: https://github.com/zibri/gemini-cli/blob/main/README.md

Installs necessary build tools and development libraries (cURL, zlib, readline) for gemini-cli on Fedora, CentOS, and RHEL systems.

```bash
sudo dnf install gcc make curl-devel readline-devel zlib-devel
```

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

### Install Prerequisites on Windows (MSYS2)

Source: https://github.com/zibri/gemini-cli/blob/main/README.md

Installs compiler and development libraries (cURL, readline, zlib) for gemini-cli using pacman within the MSYS2 CLANG64 terminal on Windows.

```bash
pacman -Suy libcurl-devel libreadline-devel clang make
```

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

### Building Gemini-CLI from Source

Source: https://context7.com/zibri/gemini-cli/llms.txt

Instructions for compiling the Gemini-CLI executable from its source code using a Makefile. This process includes cloning the repository, installing necessary development dependencies for different Linux distributions and macOS, and then running the `make` command to build the executable.

```bash
# Clone repository
git clone https://github.com/Zibri/gemini-cli.git
cd gemini-cli

# Install dependencies (Debian/Ubuntu)
sudo apt-get install build-essential libcurl4-openssl-dev libreadline-dev zlib1g-dev

# Install dependencies (Fedora/CentOS/RHEL)
sudo dnf install gcc make curl-devel readline-devel zlib-devel

# Install dependencies (macOS with Homebrew)
brew install curl readline zlib

# Build the executable
make

# The executable 'gemini-cli' is created in the current directory
# Move to PATH for system-wide access
sudo cp gemini-cli /usr/local/bin/
```

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

### Start Basic Interactive Chat Session with Gemini-CLI

Source: https://context7.com/zibri/gemini-cli/llms.txt

Initiates an interactive chat session with the Gemini-CLI. It defaults to a key-free mode if no API key is configured. You can specify a model, provide an initial prompt, attach files, or set a system prompt for the entire session. Saved sessions can also be loaded.

```bash
# Start basic interactive session (uses free mode if no API key configured)
./gemini-cli

# Start with specific model and initial prompt
./gemini-cli -m gemini-2.5-pro "Tell me about the C programming language."

# Start with file attachments and prompt
./gemini-cli my_image.png my_code.py "Describe the code and the image."

# Start with system prompt for entire session
./gemini-cli -S "You are a C code expert." "Review this code"

# Load a saved session and continue chatting
./gemini-cli --load-session my_chat
```

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

### Gemini CLI: Interactive Mode Startup

Source: https://github.com/zibri/gemini-cli/blob/main/README.md

Initiate a conversation with Gemini CLI by running the executable without any specific flags, which defaults to interactive mode. You can also combine flags with an initial prompt and files to attach. The program will process these inputs before entering the interactive session.

```bash
# Start a simple session (will use free mode if no key is configured)
./gemini-cli

# Start with a specific model and an initial prompt
./gemini-cli -m gemini-2.5-pro "Tell me about the C programming language."

# Start with initial attachments and a prompt
./gemini-cli my_image.png my_code.py "Describe the code and the image."
```

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

### Configure Gemini-CLI Generation Parameters

Source: https://context7.com/zibri/gemini-cli/llms.txt

Allows fine-tuning of the Gemini model's output behavior. Parameters include temperature for creativity, seed for reproducibility, token limits for response length, thinking budget for complex problems, and sampling parameters like top-k and top-p. A proxy can also be configured for API requests.

```bash
# Set temperature for more creative responses (0.0 to 2.0)
./gemini-cli -t 1.5 "Write a creative story"

# Set reproducible outputs with seed
./gemini-cli -s 42 "Generate a random number"

# Limit response length
./gemini-cli -o 2048 "Summarize this document"

# Set thinking budget for extended reasoning
./gemini-cli -b 8192 "Solve this complex problem"

# Configure sampling parameters
./gemini-cli --topk 40 --topp 0.95 "Generate diverse outputs"

# Use proxy for API requests
./gemini-cli -p http://localhost:8080 "Hello"
```

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

### Compile gemini-cli Program

Source: https://github.com/zibri/gemini-cli/blob/main/README.md

Compiles the gemini-cli program using the provided Makefile, which handles OS-specific settings. Creates an executable file.

```bash
make
```

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

### Gemini CLI: Control Model and Generation Parameters

Source: https://github.com/zibri/gemini-cli/blob/main/README.md

This section details the command-line flags available to control the Gemini model and its generation parameters. These flags can be used to specify models, set system prompts, adjust temperature, token limits, and more. They are essential for customizing the CLI's behavior for specific tasks.

```bash
# Show help message and exit
./gemini-cli --help

# Use the unofficial, key-free API endpoint
./gemini-cli -f

# Force non-interactive mode for a single prompt
gemini-cli -e "What is 2+2?"

# Suppress banners and info for clean scripting output
cat file.c | ./gemini-cli -q "summarize"

# Load configuration from a specific file path
./gemini-cli -c /path/to/myconfig.json

# Specify the model name to use
./gemini-cli -m gemini-2.5-pro

# Use a proxy for API requests
./gemini-cli -p http://localhost:8080

# Set a system prompt for the entire session
./gemini-cli -S "You are a C code expert."

# Set the generation temperature (e.g., 0.0 to 2.0)
./gemini-cli -t 0.25

# Set the generation seed for reproducible outputs
./gemini-cli -s 1234

# Set the maximum number of tokens in the response
./gemini-cli -o 2048

# Set the model's max 'thinking' token budget
./gemini-cli -b 8192

# Set the Top-K sampling parameter
./gemini-cli --topk 40

# Set the Top-P sampling parameter
./gemini-cli --topp 0.95

# Disable Google Search grounding
./gemini-cli -ng

# Disable URL context processing
./gemini-cli -nu

# List all available models and exit
./gemini-cli -l

# List all saved sessions and exit
./gemini-cli --list-sessions

# Load a saved session by name
./gemini-cli --load-session my_chat

# Save conversation from a non-interactive run
cat f.c | gemini-cli "prompt" --save-session f.json

# List API keys from the configuration file and exit
./gemini-cli --list-keys

# Add a new API key to the configuration file and exit
./gemini-cli --add-key

# Remove an API key from the configuration file and exit
./gemini-cli --remove-key 1

# Validate all configured API keys and exit
./gemini-cli --check-keys

# Get location information (requires --free mode)
./gemini-cli -f --loc

# Get map URL for location (requires --free mode)
./gemini-cli -f --map
```

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

### Clone gemini-cli Repository

Source: https://github.com/zibri/gemini-cli/blob/main/README.md

Clones the gemini-cli source code from GitHub and navigates into the project directory.

```bash
git clone https://github.com/Zibri/gemini-cli.git
cd gemini-cli
```

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

### Manage API Keys with Gemini-CLI

Source: https://context7.com/zibri/gemini-cli/llms.txt

Provides functionalities for managing multiple API keys, including listing them (masked for security), adding new keys, removing keys by index, and validating all configured keys. It also allows listing available models.

```bash
# List configured API keys (masked for security)
./gemini-cli --list-keys

# Add a new API key to configuration
./gemini-cli --add-key

# Remove API key by index
./gemini-cli --remove-key 1

# Validate all configured API keys
./gemini-cli --check-keys

# List available models
./gemini-cli -l
```

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

### Run gemini-cli in Key-Free Mode

Source: https://github.com/zibri/gemini-cli/blob/main/README.md

Executes the gemini-cli client using the key-free mode with the '-f' or '--free' flag, suitable for initial testing or when an API key is not available.

```bash
./gemini-cli -f "Hello, world!"
```

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

### Gemini-CLI API Key Configuration via Environment Variables

Source: https://context7.com/zibri/gemini-cli/llms.txt

Configure Gemini-CLI using environment variables for secure API key management. The `GEMINI_API_KEY` variable sets the primary API key, while `GEMINI_API_KEY_ORIGIN` specifies the origin for HTTP referrer-restricted keys. These environment variables take precedence over configuration files.

```bash
# Set API key via environment (highest priority)
export GEMINI_API_KEY="your_api_key_here"

# Set origin for HTTP referrer-restricted keys
export GEMINI_API_KEY_ORIGIN="https://my-app.com"

# Example usage after setting environment
./gemini-cli "Hello, world!"
```

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

### Attach Files and URLs in Gemini-CLI Interactive Mode

Source: https://context7.com/zibri/gemini-cli/llms.txt

Allows users to attach files, images, and URLs to prompts for multimodal conversations within the interactive Gemini-CLI. This includes attaching single or multiple files, pasting text from the clipboard, and managing pending or history attachments.

```bash
# Attach file with optional immediate prompt
/attach mycode.py "Review this Python code"

# Attach multiple files (run command multiple times)
/attach image1.png
/attach image2.png
"Compare these images"

# Paste text from clipboard (Ctrl+D to end)
/paste

# Manage pending attachments
/attachments list              # List pending attachments
/attachments remove 0          # Remove attachment by index
/attachments clear             # Clear all pending

# Manage history attachments
/history attachments list      # List attachments in history
/history attachments remove 2:1 # Remove by msg:part ID
```

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

### Set GEMINI_API_KEY_ORIGIN Environment Variable

Source: https://github.com/zibri/gemini-cli/blob/main/README.md

Sets the GEMINI_API_KEY_ORIGIN environment variable to specify the allowed origin for restricted API keys, sending the required 'Origin' HTTP header.

```bash
export GEMINI_API_KEY_ORIGIN="https://my-app.com"
```

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

### Gemini-CLI Generation Control Commands

Source: https://context7.com/zibri/gemini-cli/llms.txt

Control various aspects of Gemini model generation during an interactive session. This includes setting system prompts, adjusting response quality with deep modes, managing temperature and token limits, configuring sampling parameters, toggling features like grounding and URL context, managing API keys within the session, and saving/loading configurations.

```bash
# System prompt
/system You are a helpful coding assistant.
/clear_system            # Remove system prompt

# Deep mode for higher quality responses
/deep Explain quantum computing
/deeper Write a comprehensive guide to C memory management

# Temperature and token control
/temp 0.5                # Set temperature
/maxtokens 4096          # Set max output tokens
/budget 16384            # Set thinking budget

# Sampling parameters
/topk 40                 # Set Top-K sampling
/topp 0.95               # Set Top-P sampling

# Feature toggles
/grounding on            # Enable Google Search grounding
/grounding off
/urlcontext on           # Enable URL context fetching
/urlcontext off

# Key management in session
/keys list               # List loaded API keys
/keys add <key>          # Add key for current session
/keys remove 0           # Remove key by index
/keys check              # Validate loaded keys

# Configuration
/config save             # Save current settings to config file
/config load             # Reload settings from config file
/models                  # List available models from API
```

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

### Interactive Commands for Session and History Management in Gemini-CLI

Source: https://context7.com/zibri/gemini-cli/llms.txt

These commands are used within the interactive mode of Gemini-CLI to manage the conversation. They include help, clearing history, viewing statistics, starting/listing/saving/loading/deleting sessions, and exporting/importing history in JSON or Markdown formats.

```bash
# In interactive mode:
/help                    # Show all available commands
/clear                   # Clear conversation history and attachments
/stats                   # Show session statistics (tokens, model, etc.)

# Session management
/session new            # Start new unsaved session
/session list           # List all saved sessions
/session save myproject # Save current chat to named session
/session load myproject # Load a named session
/session delete myproject # Delete a session

# History export/import
/save conversation.json  # Export history to JSON file
/load conversation.json  # Import history from JSON file
/export chat.md          # Export to human-readable Markdown
/savelast response.txt   # Save only last model response
```

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

### Set GEMINI_API_KEY Environment Variable

Source: https://github.com/zibri/gemini-cli/blob/main/README.md

Sets the GEMINI_API_KEY environment variable to provide your API key for the official Google Gemini API. This has the highest priority for configuration.

```bash
export GEMINI_API_KEY="your_api_key_here"
```

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

### Gemini-CLI Configuration File Structure (config.json)

Source: https://context7.com/zibri/gemini-cli/llms.txt

Defines the structure for the persistent configuration file used by Gemini-CLI. This JSON file allows users to set default parameters such as API keys, allowed origins, model selection, proxy settings, temperature, seed, system prompts, feature toggles, and token limits. The file location varies by operating system.

```json
{
  "api_keys": [
    "your_first_api_key",
    "your_second_api_key"
  ],
  "origins": [
    "https://your-allowed-origin.com",
    "default"
  ],
  "model": "gemini-2.5-pro",
  "proxy": "http://localhost:8080",
  "temperature": 0.75,
  "seed": 42,
  "system_prompt": "You are a helpful and concise assistant.",
  "google_grounding": true,
  "url_context": true,
  "max_output_tokens": 8192,
  "thinking_budget": -1,
  "top_k": 40,
  "top_p": 0.95
}
```

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

### Gemini-CLI Key-Free Mode Usage

Source: https://context7.com/zibri/gemini-cli/llms.txt

Utilize Gemini-CLI without requiring an API key by connecting to an unofficial API endpoint. This mode is suitable for immediate testing and exploration. Specific flags like `-f` enable key-free mode, and additional options like `--loc` and `--map` provide location-based information.

```bash
# Explicit key-free mode
./gemini-cli -f "Hello, world!"

# Key-free mode is automatic if no API key is configured
./gemini-cli "Hello without a key"

# Get location information (key-free mode only)
./gemini-cli -f --loc

# Get map URL for location (key-free mode only)
./gemini-cli -f --map
```

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

### Use Gemini-CLI in Non-Interactive Scripting Mode

Source: https://context7.com/zibri/gemini-cli/llms.txt

Enables Gemini-CLI for use in scripts and pipelines, automatically engaging when stdin or stdout are piped. This mode is useful for tasks like summarizing code, generating commit messages, or processing files and saving sessions. Non-interactive mode can also be forced for single prompts.

```bash
# Summarize a source file with quiet mode (only prints response)
cat my_complex_function.c | ./gemini-cli -q "Explain what this C code does"

# Generate git commit message using stdin attachment flag
git diff --staged | ./gemini-cli -e "Write a concise git commit message for: -"

# Process file and save session for later review
cat file.c | ./gemini-cli "analyze this code" --save-session analysis.json

# Force non-interactive mode for single prompt
./gemini-cli -e "What is 2+2?"
```

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

### Gemini CLI: Non-Interactive / Scripting Mode

Source: https://github.com/zibri/gemini-cli/blob/main/README.md

Gemini CLI automatically enters non-interactive mode when data is piped to it or when the `-e` flag is used. This mode is suitable for scripting and automated tasks where direct user interaction is not required.

```bash
# Summarize a source file, suppressing all non-essentials
cat my_complex_function.c | ./gemini-cli -q "Explain what this C code does in simple terms"

# Generate a git commit message from the staged changes using the stdin attachment flag
git diff --staged | ./gemini-cli -e "Write a concise, imperative git commit message for these changes: -"
```
Tokens:
Raw