Getting Started with Abbenay

July 7, 2026 · View on GitHub

This guide walks you through installing, configuring, and using Abbenay.

1. Install

Download the latest release for your platform. The binary is a Node.js Single Executable Application (SEA) — no Node.js installation required.

Release artifacts are named abbenay-daemon-<platform>-<arch>. Rename or symlink to aby for convenience:

# Linux / macOS — rename and move to PATH
chmod +x abbenay-daemon-linux-x64
sudo mv abbenay-daemon-linux-x64 /usr/local/bin/aby

If you install via npm (npm install -g @abbenay/daemon), both aby and abbenay are available on PATH automatically.

All examples in this guide use aby.

Option B: Build from source

git clone https://github.com/redhat-developer/abbenay.git
cd abbenay

./bootstrap.sh                 # downloads Node.js + uv into .build-tools/
source .build-tools/env.sh     # puts them on PATH
npm install
node build.js                  # builds SEA binary + VSIX + dist archives

Option C: Container image

git clone https://github.com/redhat-developer/abbenay.git
cd abbenay
podman build -f Containerfile -t abbenay:latest .

podman run -d --name abbenay \
  -v ./config.yaml:/home/abbenay/.config/abbenay/config.yaml:ro \
  -e OPENROUTER_API_KEY=sk-or-... \
  -p 8787:8787 \
  abbenay:latest

See CONTAINER.md for full container deployment docs including Kubernetes manifests.

Option D: Run from source (development)

git clone https://github.com/redhat-developer/abbenay.git
cd abbenay
npm install
cd packages/daemon
npx tsx src/daemon/index.ts daemon   # run daemon directly

2. Configure a provider

Abbenay needs at least one LLM provider. Create a config file at the platform-appropriate location:

PlatformConfig directory
Linux$XDG_CONFIG_HOME/abbenay/ (default ~/.config/abbenay/)
macOS~/Library/Application Support/abbenay/
Windows%APPDATA%\abbenay\
# Linux example
mkdir -p ~/.config/abbenay

config.yaml:

providers:
  my-openai:
    engine: openai
    api_key_env_var_name: "OPENAI_API_KEY"
    models:
      gpt-4o: {}
      gpt-4o-mini: {}

Set the API key in your environment:

export OPENAI_API_KEY="sk-..."

Or use the system keychain instead of env vars:

providers:
  my-openai:
    engine: openai
    api_key_keychain_name: "OPENAI_API_KEY"
    models:
      gpt-4o: {}

Then store the key via the web dashboard or CLI.

Local models (no API key needed)

providers:
  local-ollama:
    engine: ollama
    models:
      llama3.2: {}
      qwen2.5-coder: {}

Ollama must be running at http://localhost:11434 (the default).

Red Hat AI (Inference Server or MaaS)

providers:
  redhat-inference:
    engine: redhat
    models:
      RedHatAI/Llama-3.2-1B-Instruct-FP8: {}

The Inference Server must be running at http://127.0.0.1:8000/v1. For OpenShift AI MaaS, set base_url and api_key_env_var_name. See REDHAT_AI.md for both profiles.

See CONFIGURATION.md for all options.

3. Start Abbenay

All-in-one

aby start

This launches the daemon, web dashboard, OpenAI-compatible API, and MCP server on port 8787.

Individual services

aby daemon                    # gRPC daemon only (background-ready)
aby web -p 8787               # Web dashboard
aby serve -p 8787             # OpenAI-compatible API
aby status                    # Check if running
aby stop                      # Stop everything

4. Chat from the CLI

aby chat -m my-openai/gpt-4o

The model ID is <provider-name>/<model-name> from your config.

Options:

aby chat -m my-openai/gpt-4o -s "You are a helpful assistant"   # system prompt
aby chat -m my-openai/gpt-4o -p coder                          # apply a policy
aby chat -m my-openai/gpt-4o --no-tools                        # disable tools
aby chat -m my-openai/gpt-4o --json                            # JSON output (for piping)

Type your message and press Enter to send. Ctrl+D to exit.

5. Use sessions for persistent conversations

Sessions save your conversation so you can resume later.

# Start a new session
aby chat -m my-openai/gpt-4o --session new

# Resume an existing session
aby chat --session <session-id>

# List all sessions
aby sessions list

# Show a session's messages
aby sessions show <session-id>

# Delete a session
aby sessions delete <session-id>

Sessions are stored as JSON in a platform-specific data directory:

PlatformSession directory
Linux$XDG_DATA_HOME/abbenay/sessions/ (default ~/.local/share/abbenay/sessions/)
macOS~/Library/Application Support/abbenay/sessions/
Windows%LOCALAPPDATA%\abbenay\sessions\

Every 10 user messages, a background LLM call generates a short summary.

6. Use the OpenAI-compatible API

Start the server:

aby serve -p 8787

Then point any OpenAI-compatible client at it:

# List models
curl http://localhost:8787/v1/models

# Chat (streaming)
curl http://localhost:8787/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "my-openai/gpt-4o",
    "messages": [{"role": "user", "content": "Hello!"}],
    "stream": true
  }'

With the OpenAI Python SDK

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8787/v1", api_key="unused")
response = client.chat.completions.create(
    model="my-openai/gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(response.choices[0].message.content)

With Cursor / Continue / aider

Set the API base URL to http://localhost:8787/v1 in your tool's settings. The API key field can be any non-empty string.

7. Use the web dashboard

aby web

Open http://localhost:8787 in your browser to:

  • Add and configure providers
  • Store API keys in the system keychain
  • Enable/disable models
  • Test chat with streaming responses

8. Connect MCP servers

Abbenay can connect to external MCP servers and aggregate their tools.

Add to your config:

mcp_servers:
  filesystem:
    transport: stdio
    command: npx
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/home/user"]
    enabled: true
  github:
    transport: http
    url: http://localhost:3001/mcp
    enabled: true

Tools from connected MCP servers are automatically available in chat. Tool approval policies control which tools can execute without confirmation.

9. VS Code integration

Install the Abbenay VS Code extension (VSIX):

node build.js --code-install

The extension:

  • Connects to the daemon automatically on activation
  • Registers all configured models with VS Code's Language Model API
  • Other extensions can use Abbenay models via vscode.lm.selectChatModels({ vendor: 'abbenay' })

10. Discover models

# Show configured models
aby list-models

# Discover what an engine offers (fetches from provider API)
aby list-models --discover ollama
aby list-models --discover openai
aby list-models --discover anthropic

# Show available engines
aby list-engines

Next steps