Getting Started

Termineer is a self-directing AI coding engineer that operates from your terminal. To get started, you'll need to configure your API keys and understand the basic configuration options.

API Keys

Termineer supports multiple LLM providers. You'll need at least one API key to use the application.

ANTHROPIC_API_KEY

Required for using Claude models like 'claude-3-opus', 'claude-3-sonnet', and 'claude-3-haiku'. Get your API key from Anthropic

GOOGLE_API_KEY

Serves two purposes: (1) For web search functionality and (2) For using Google's Gemini models like 'gemini-1.5-pro'. Get your API key from Google Cloud

OPENROUTER_API_KEY

Required for accessing models through OpenRouter, which provides a unified API for various models including GPT-4o, Claude, and more. Get your API key from OpenRouter

Optional settings:

OPENROUTER_SITE_URL - Your application's URL (for request ranking)
OPENROUTER_SITE_NAME - Your application's name (for request ranking)

DEEPSEEK_API_KEY

Required for using DeepSeek models like 'deepseek-chat' and 'deepseek-reasoner'. Get your API key from DeepSeek

Configuration Methods

.env File Support

Termineer supports loading configuration from .env files. Create a .env file in your project directory with your API keys:

                            ANTHROPIC_API_KEY=sk-ant-your-key-here
GOOGLE_API_KEY=your-google-key-here
                        

Termineer checks the following locations for .env files:

Current directory (./.env)
The env subdirectory (./env/.env)
Parent directory (../.env)
Home directory (~/.env)

Environment Variables

You can also set these as environment variables directly:

                            export ANTHROPIC_API_KEY=sk-ant-your-key-here
export GOOGLE_API_KEY=your-google-key-here
                        

Advanced Configuration

.termineer Directory

Termineer uses a special directory structure for project-specific configuration. You can create a .termineer directory in your project root to customize behavior.

Project Information

Create an info file in the .termineer directory with project information. This will be loaded automatically at the start of each agent conversation.

                        # Project information:
# My Awesome Project
This is a description of my project that Termineer will use to understand the context.

## Technologies
- Python 3.9
- Django
- PostgreSQL

## Architecture
The project follows a standard MVC architecture with:
- models/ - Database models and business logic
- views/ - Request handlers and response formatting
- templates/ - HTML templates for rendering
- static/ - CSS, JavaScript, and other static assets

## API Endpoints
- GET /api/users - List all users
- POST /api/users - Create a new user
- GET /api/users/:id - Get a specific user
                    

The content should follow Markdown formatting guidelines. Termineer will automatically include your current working directory and prefix this information with "Project information:".

Automatic File Inclusion

Create an autoinclude file in the .termineer directory to automatically include files in your context. Each line is treated as a glob pattern:

                        # Include key configuration files
config/*.json
README.md

# Include important source files
src/main.rs
src/config.rs

# Include all API-related files
src/api/*.rs

# Comments start with #
# Empty lines are ignored
                    

Files matching these patterns will be automatically loaded and added to the agent's context at startup. Binary files and certain extensions (.exe, .jpg, etc.) are automatically excluded. Use this feature to give your agent immediate access to important project files.

Model Context Protocol (MCP) - Experimental

MCP is an experimental feature that allows Termineer to interact with specialized tools and services through a protocol. This enables advanced functionalities beyond the built-in tools. Note: Termineer currently only supports standard input/output MCP servers.

Configuring MCP Servers

MCP servers are configured in one or both of these locations:

Home directory: ~/.termineer/mcp/config.json
Local project directory: .termineer/config.json

Configurations from both locations are merged, with local settings taking precedence. This allows for system-wide defaults with project-specific overrides.

Example MCP configurations:

Home config (~/.termineer/mcp/config.json):

                        {
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/username/Documents",
        "/Users/username/Downloads"
      ],
      "env": {
        "NODE_ENV": "production",
        "DEBUG": "mcp:*"
      }
    },
    "openapi": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-openapi"
      ],
      "env": {
        "PORT": "9001"
      }
    }
  }
}
                    

Project-specific config (.termineer/config.json):

                        {
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "./project-files",
        "/tmp/cache"
      ],
      "env": {
        "API_KEY": "project-specific-key"
      }
    },
    "project-tool": {
      "command": "./tools/my-custom-tool.js",
      "args": ["--serve"],
      "env": {
        "PORT": "9002"
      }
    }
  }
}
                    

Resulting merged configuration:

When both configurations exist, they'll be merged as follows:

"filesystem" from the project config overrides the home config (local takes precedence)
"openapi" from the home config is preserved
"project-tool" from the project config is added

Environment Variables: You can specify environment variables to be passed to MCP servers using the env field. This is useful for setting API keys, debug modes, or other configuration without exposing them in command arguments.

Tip: Use the .termineer/autoinclude file (described in the Automatic File Inclusion section above) to include your MCP configuration files in the agent's context at startup. This can be helpful when working with custom MCP tools that require specific documentation or examples.

Command-Line Options

Termineer supports various command-line options to customize behavior:

Option	Description	Example
`--model`	Specify the AI model to use	`--model claude-3-haiku-20240307`
`--kind`	Specify the agent kind/template	`--kind researcher`
`--grammar`	Specify the grammar type (xml, markdown)	`--grammar xml`
`--no-tools`	Disable tools	`--no-tools`
`--thinking-budget`	Set thinking token budget	`--thinking-budget 16384`

Usage Examples

Interactive mode (recommended for most uses):

termineer

Single query mode with custom model:

termineer --model claude-3-haiku-20240307 "Analyze this log file for errors"

Specialized agent kind:

termineer --kind researcher "Find best practices for API security"

TUI Mode and Commands

Termineer provides a rich Terminal User Interface (TUI) in interactive mode with keyboard shortcuts, command history, and special commands.

Command Modes

Termineer offers special command modes triggered by prefix characters:

Slash Commands Mode

Type a slash (/) followed by a command to perform special actions:

Command	Description
`/help`	Show available commands
`/exit` or `/quit`	Exit the application
`/interrupt`	Interrupt the current agent
`/model MODEL`	Set the model for the current agent (e.g., `/model claude-3-haiku-20240307`)
`/tools on\|off`	Enable or disable tools
`/system TEXT`	Set the system prompt
`/reset`	Reset the conversation
`/thinking NUMBER`	Set thinking budget in tokens (e.g., `/thinking 10000`)

Agent Selection Mode

Use the pound symbol (#) to switch between agents:

#ID - Switch to agent with the specified ID (e.g., #1)
#NAME - Switch to agent by name (e.g., #researcher)

Interrupting Operations

Termineer provides a multi-level interrupt system:

Ctrl+C - Interrupt the current operation (tool execution or agent processing)
Ctrl+C (pressed twice within 3 seconds) - Exit the application
/interrupt - Command to explicitly interrupt the current agent

Termineer User Manual