chatgpt-cli MCP工具

Installation

Getting Started

1. Set the OPENAI_API_KEY environment variable to your ChatGPT secret key. To set the environment variable, you can add the following line to your shell profile (e.g., ~/.bashrc, ~/.zshrc, or ~/.bash_profile), replacing your_api_key with your actual key:

    export OPENAI_API_KEY="your_api_key"
    

1. To enable history tracking across CLI calls, create a ~/.chatgpt-cli directory using the command:

    mkdir -p ~/.chatgpt-cli
    

Once this directory is in place, the CLI automatically manages the message history for each "thread" you converse with. The history operates like a sliding window, maintaining context up to a configurable token maximum. This ensures a balance between maintaining conversation context and achieving optimal performance.

By default, if a specific thread is not provided by the user, the CLI uses the default thread and stores the history at ~/.chatgpt-cli/history/default.json. You can find more details about how to configure the thread parameter in the Configuration section of this document.

1. Try it out:

    chatgpt what is the capital of the Netherlands
    

1. To start interactive mode, use the -i or --interactive flag:

    chatgpt --interactive
    

If you want the CLI to automatically create a new thread for each session, ensure that the auto_create_new_thread configuration variable is set to true. This will create a unique thread identifier for each interactive session.

5. To use the pipe feature, create a text file containing some context. For example, create a file named context.txt with the following content:

    Kya is a playful dog who loves swimming and playing fetch.
    

Then, use the pipe feature to provide this context to ChatGPT:

    cat context.txt | chatgpt "What kind of toy would Kya enjoy?"
    

1. To list all available models, use the -l or --list-models flag:

    chatgpt --list-models
    

1. For more options, see:

   chatgpt --help
   

Uninstallation

If for any reason you wish to uninstall the ChatGPT CLI application from your system, you can do so by following these steps:

Configuration

The ChatGPT CLI adopts a four-tier configuration strategy, with different levels of precedence assigned to flags, environment variables, a config.yaml file, and default values, in that respective order:

1. Flags: Command-line flags have the highest precedence. Any value provided through a flag will override other configurations. 2. Environment Variables: If a setting is not specified by a flag, the corresponding environment variable (prefixed with the name field from the config) will be checked. 3. Config file (config.yaml): If neither a flag nor an environment variable is set, the value from the config.yaml file will be used. 4. Default Values: If no value is specified through flags, config.yaml, or environment variables, the CLI will fall back to its built-in default values.

General Configuration

LLM-Specific Configuration

Agent Configuration

You can also use flags, for example:

chatgpt "what files are here?" --agent --agent-work-dir /tmp

allowed_tools: [shell, llm, files]
denied_shell_commands: [rm, sudo, dd, mkfs, shutdown, reboot]
allowed_file_ops: [read, write]

Custom Config, Cache and Data Directory

By default, ChatGPT CLI stores configuration and history files in the ~/.chatgpt-cli directory. However, you can easily override these locations by setting environment variables, allowing you to store configuration and history in custom directories.

Example for Custom Directories

To change the default configuration or data directories, set the appropriate environment variables:

export OPENAI_CONFIG_HOME="/custom/config/path"
export OPENAI_DATA_HOME="/custom/data/path"
export OPENAI_CACHE_HOME="/custom/cache/path"

If these environment variables are not set, the application defaults to ~/.chatgpt-cli for configuration files and ~ /.chatgpt-cli/history for history.

Switching Between Configurations with --target

You can maintain multiple configuration files side by side and switch between them using the --target flag. This is especially useful if you use multiple LLM providers (like OpenAI, Perplexity, Azure, etc.) or have different contexts or workflows that require distinct settings.

How it Works

When you use the --target flag, the CLI loads a config file named:

config.<target>.yaml

For example:

chatgpt --target perplexity --config

This will load:

~/.chatgpt-cli/config.perplexity.yaml

If the --target flag is not provided, the CLI falls back to:

~/.chatgpt-cli/config.yaml

Example Setup

You can maintain the following structure:

~/.chatgpt-cli/
├── config.yaml # Default (e.g., OpenAI)
├── config.perplexity.yaml # Perplexity setup
├── config.azure.yaml # Azure-specific config
└── config.llama.yaml # LLaMA setup

Then switch between them like so:

chatgpt --target azure "Explain Azure's GPT model differences"
chatgpt --target perplexity "What are some good restaurants in the Red Hook area"

Or just use the default:

chatgpt "What's the capital of Sweden?"

CLI and Environment Interaction

The value of --target is never persisted — it must be explicitly passed for each run. The config file corresponding to the target is loaded before any environment variable overrides are applied. * Environment variables still follow the name: field inside the loaded config, so name: perplexity enables PERPLEXITY_API_KEY.

Variables for interactive mode:

• %date: The current date in the format YYYY-MM-DD.
• %time: The current time in the format HH:MM:SS.
• %datetime: The current date and time in the format YYYY-MM-DD HH:MM:SS.
• %counter: The total number of queries in the current session.
• %usage: The usage in total tokens used (only works in query mode).

The defaults can be overridden by providing your own values in the user configuration file. The structure of this file mirrors that of the default configuration. For instance, to override the model and max_tokens parameters, your file might look like this:

model: gpt-3.5-turbo-16k
max_tokens: 4096

This alters the model to gpt-3.5-turbo-16k and adjusts max_tokens to 4096. All other options, such as url , completions_path, and models_path, can similarly be modified.

You can also add custom HTTP headers to all API requests. This is useful when working with proxies, API gateways, or services that require additional headers:

custom_headers:
  X-Custom-Header: "custom-value"
  X-API-Version: "v2"
  X-Client-ID: "my-client-id"

If the user configuration file cannot be accessed or is missing, the application will resort to the default configuration.

Another way to adjust values without manually editing the configuration file is by using environment variables. The name attribute forms the prefix for these variables. As an example, the model can be modified using the OPENAI_MODEL environment variable. Similarly, to disable history during the execution of a command, use:

OPENAI_OMIT_HISTORY=true chatgpt what is the capital of Denmark?

This approach is especially beneficial for temporary changes or for testing varying configurations.

Moreover, you can use the --config or -c flag to view the present configuration. This handy feature allows users to swiftly verify their current settings without the need to manually inspect the configuration files.

chatgpt --config

Executing this command will display the active configuration, including any overrides instituted by environment variables or the user configuration file.

To facilitate convenient adjustments, the ChatGPT CLI provides flags for swiftly modifying the model, thread , context-window and max_tokens parameters in your user configured config.yaml. These flags are --set-model , --set-thread, --set-context-window and --set-max-tokens.

For instance, to update the model, use the following command:

chatgpt --set-model gpt-3.5-turbo-16k

This feature allows for rapid changes to key configuration parameters, optimizing your experience with the ChatGPT CLI.

Azure Configuration

For Azure, you need to configure these, or similar, value

name: azure
api_key: <your azure api key>
url: https://<your_resource>.openai.azure.com
completions_path: /openai/deployments/<your_deployment>/chat/completions?api-version=<your_api>
auth_header: api-key
auth_token_prefix: " "

You can set the API key either in the config.yaml file as shown above or export it as an environment variable:

export AZURE_API_KEY=<your_key>

Perplexity Configuration

For Perplexity, you will need something equivelent to the following values:

name: perplexity
api_key: <your perplexity api key>
model: sonar
url: https://api.perplexity.ai

You can set the API key either in the config.yaml file as shown above or export it as an environment variable:

export PERPLEXITY_API_KEY=<your_key>

You can set the API key either in the config.yaml file as shown above or export it as an environment variable:

export AZURE_API_KEY=<your_key>

302.AI Configuration

I successfully tested 302.AI with the following values

name: ai302 # environment variables cannot start with numbers
api_key: <your 302.AI api key>
url: https://api.302.ai

You can set the API key either in the config.yaml file as shown above or export it as an environment variable:

export AI302_API_KEY=<your_key>

Atlas Cloud Configuration

Atlas Cloud exposes an OpenAI-compatible API at https://api.atlascloud.ai/v1, giving access to 300+ models (DeepSeek, Llama, Qwen, and more) through a single endpoint. Because it speaks the OpenAI Chat Completions format, it works with ChatGPT CLI out of the box using the following values:

name: atlascloud
api_key: <your Atlas Cloud api key>
model: deepseek-ai/deepseek-v4-pro
url: https://api.atlascloud.ai/v1

You can set the API key either in the config.yaml file as shown above or export it as an environment variable:

export ATLASCLOUD_API_KEY=<your_key>

You can browse the full model catalog and create an API key from the Atlas Cloud dashboard.