Abbenay

Abbenay provides a unified daemon that connects your Ansible developer tools to the AI models you choose — local, cloud, or Red Hat AI — through a single configuration file.

Why this matters

AI coding assistants generate better Ansible automation when connected to AI models that understand your environment, your collections, and your organizational policies. Without a unified provider layer, each tool embeds its own LLM client — duplicating configuration, fragmenting secret management, and locking you into a single provider.

How Abbenay helps

Abbenay is a background daemon that centralizes AI model access for the Ansible developer toolchain. Configure your providers once, and every consuming tool — the Ansible VS Code extension, CLI scripts, or custom applications — connects through the same daemon.

Key capabilities:

• Bring Your Own Model (BYOM) — use any model from 20 production provider engines (plus a mock engine for testing), including OpenAI, Anthropic, Google Gemini, Ollama, and Red Hat AI. Run aby list-engines or see the configuration reference for the full list.
• One configuration file — define all providers, models, and API keys in a single config.yaml file (for example, ~/.config/abbenay/config.yaml on Linux).
• Centralized secret management — store API keys in your system keychain or environment variables.
• OpenAI-compatible API — expose any configured model through a standard /v1/chat/completions endpoint for tools that speak the OpenAI protocol.

Note

Abbenay ships standalone and is not bundled in the Ansible Automation Platform installer. It coexists with Ansible Lightspeed — Abbenay is the provider-agnostic BYOM layer, while Lightspeed remains a separate Red Hat-hosted AI service.

Get started

1. Install Abbenay — download the pre-built binary, pull the container image, or (on Windows) run from source.
2. Configure a provider — set up Ollama for local development, a cloud provider for BYOM, or Red Hat AI for enterprise deployments.
3. Verify your connection — launch Abbenay and send a test prompt.

For the full list of settings, security options, and engine reference, see the Abbenay configuration reference.

Related links

• Install Abbenay
• Set up a local model with Ollama
• Connect a cloud provider
• Connect Red Hat AI Inference
• Verify your connection
• Abbenay configuration reference

Architecture and positioning

Abbenay sits between your Ansible developer tools and the model providers you configure. A single daemon exposes a gRPC API for integrated tools (VS Code extension, CLI), an OpenAI-compatible HTTP API for generic clients, an MCP server for AI agents, and a web dashboard for configuration and approvals. It is the provider-agnostic BYOM layer in the Ansible developer toolchain — complementary to Ansible Lightspeed, which remains a separate Red Hat-hosted service.

For component-level design, see the Abbenay architecture guide. For product positioning and ecosystem context, see the Abbenay product overview.

Install Abbenay

Prerequisites

• Linux x86_64, Linux ARM64, macOS Apple Silicon, or Windows (see the Windows notes).
• For the container method: Podman or a compatible container runtime.

Choose one of the following installation methods.

Pre-built binary (recommended)

The pre-built binary is a Node.js Single Executable Application (SEA) that requires no runtime dependencies.

1. Download the latest release archive for your platform from the Abbenay releases page:

   Platform	Archive name
   Linux x86_64	abbenay-<version>-linux-x64.tar.gz
   Linux ARM64	abbenay-<version>-linux-arm64.tar.gz
   macOS Apple Silicon	abbenay-<version>-darwin-arm64.tar.gz

2. Extract the archive:

   tar xzf abbenay-<version>-<platform>.tar.gz

3. Rename the binary and move it to a directory on your PATH:

   chmod +x abbenay-daemon
   sudo mv abbenay-daemon /usr/local/bin/aby

4. Verify the installation:

   aby --version

Container image

Pull the pre-built container image from GitHub Container Registry. The image is available for linux/amd64 and linux/arm64.

1. Pull the image:

   podman pull ghcr.io/redhat-developer/abbenay:latest

2. Verify the image:

   podman run --rm ghcr.io/redhat-developer/abbenay:latest aby --version

Note

For container deployments, use environment variables for API key storage (api_key_env_var_name). System keychain storage is not available inside containers. For full container deployment details, including Kubernetes manifests, see the Abbenay container guide.

Windows

Windows builds run from source (no pre-built SEA binary yet):

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

See Windows support below for how Abbenay’s runtime paths and transport differ from Linux and macOS.

Windows support

Abbenay runs on Windows with two platform-specific differences from Linux and macOS:

Aspect	Linux	macOS	Windows
Runtime directory	XDG data dir	Platform data dir	%TEMP%\abbenay
Local daemon transport	Unix domain socket	Unix domain socket	Loopback TCP
Config directory	~/.config/abbenay	~/Library/Application Support/abbenay	%APPDATA%\abbenay

Because Windows has no native Unix domain sockets, the daemon falls back to a loopback TCP listener for local IPC (CLI, VS Code extension) instead of the Unix socket used on Linux and macOS. This is functionally equivalent for single-user, local-machine use — the listener still binds to 127.0.0.1 only, so it is not reachable from other hosts.

What to do next

Configure a provider. See Set up a local model with Ollama, Connect a cloud provider, or Connect Red Hat AI Inference.

Set up a local model with Ollama

Configure Abbenay to use Ollama so that you can get AI-powered Ansible assistance without external network access.

Prerequisites

• Abbenay is installed. See Install Abbenay.
• Ollama is installed and running at http://localhost:11434.
• At least one model is pulled in Ollama (for example, ollama pull llama3.2).

Procedure

1. Create the Abbenay configuration directory and open config.yaml:

   Linux

   mkdir -p ~/.config/abbenay
   vi ~/.config/abbenay/config.yaml

   macOS

   mkdir -p ~/Library/Application\ Support/abbenay
   vi ~/Library/Application\ Support/abbenay/config.yaml

   Windows

   mkdir $env:APPDATA\abbenay
   notepad $env:APPDATA\abbenay\config.yaml

2. Add the Ollama provider configuration:

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

3. Save the file.

What to do next

Start Abbenay and verify your connection. See Verify your connection.

Connect a cloud provider

Configure Abbenay to use a cloud AI provider so that you can use your existing AI investments with Ansible developer tools.

Prerequisites

• Abbenay is installed. See Install Abbenay.
• You have an API key from your cloud AI provider.

Abbenay supports 20 production provider engines, plus a mock engine for testing. This procedure uses OpenAI as an example. Run aby list-engines to see all engine IDs, or see the configuration reference for the full list.

Procedure

1. Create the Abbenay configuration directory if it does not exist yet, then open config.yaml (see Set up a local model with Ollama for platform-specific paths).

2. List all supported engine IDs:

   aby list-engines

3. Add the cloud provider configuration:

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

4. Set the API key as an environment variable:

   export OPENAI_API_KEY="your-api-key-here"

   Alternatively, store the API key in your system keychain for persistent, secure storage:

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

   Note

   System keychain storage is not available in container deployments. Use environment variables for containers.

Some commonly used cloud engines:

Provider	Engine ID	Default env var
OpenAI	openai	OPENAI_API_KEY
Anthropic	anthropic	ANTHROPIC_API_KEY
Google Gemini	gemini	GOOGLE_API_KEY
Mistral	mistral	MISTRAL_API_KEY
xAI (Grok)	xai	XAI_API_KEY
DeepSeek	deepseek	DEEPSEEK_API_KEY
Groq	groq	GROQ_API_KEY
Cohere	cohere	COHERE_API_KEY
Amazon Bedrock	bedrock	(AWS credentials)
OpenRouter	openrouter	OPENROUTER_API_KEY
Plus 10 more production engines	—	—

The table above lists 10 of the 20 production engines. For the complete list (including mock for testing), see the configuration reference.

What to do next

Start Abbenay and verify your connection. See Verify your connection.

Connect Red Hat AI Inference

Configure Abbenay to use a Red Hat AI Inference endpoint so that you can use enterprise-governed models for Ansible development.

Prerequisites

• Abbenay is installed. See Install Abbenay.
• A Red Hat AI Inference endpoint is running and serving at least one model. For installation and configuration, see the Red Hat AI Inference documentation.

Red Hat AI Inference is a standalone vLLM instance that exposes an OpenAI-compatible REST API. It runs locally, on a RHEL AI host, or in an OpenShift container. For full details on both deployment profiles (Inference Server and OpenShift AI MaaS), see the Red Hat AI engine guide and the Red Hat AI engine reference in the configuration reference.

Procedure

1. Verify that your Red Hat AI Inference endpoint is running and serving models:

   curl http://127.0.0.1:8000/v1/models

2. Open the Abbenay config.yaml and add the Red Hat AI provider configuration:

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

   Replace the model ID with whatever your server’s /v1/models endpoint reports.

3. Optional — if your endpoint requires authentication (started with the --api-key flag), add an API key:

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

   export REDHAT_AI_API_KEY="your-server-api-key"

4. Optional — if your endpoint runs on a non-default port or remote host, set base_url:

   providers:
     redhat-inference:
       engine: redhat
       base_url: 'http://192.168.1.100:8080/v1'
       models:
         RedHatAI/Llama-3.2-1B-Instruct-FP8: {}

5. Optional — for servers with self-signed or internal CA certificates:

   export NODE_EXTRA_CA_CERTS="/path/to/ca-bundle.crt"

If Abbenay runs inside a container and the Red Hat AI Inference endpoint runs on the host, use:

providers:
  redhat-inference:
    engine: redhat
    base_url: 'http://host.containers.internal:8000/v1'
    models:
      RedHatAI/Llama-3.2-1B-Instruct-FP8: {}

Note

This covers Red Hat AI Inference (a standalone vLLM instance). To connect to a Red Hat OpenShift AI Models-as-a-Service (MaaS) endpoint instead, use the openai engine (or the redhat engine with base_url set to your MaaS /v1 route) — see the Red Hat AI engine reference for both profiles.

What to do next

Start Abbenay and verify your connection. See Verify your connection.

Verify your connection

Start the Abbenay daemon and send a test prompt to verify that your AI model is connected and responding.

Prerequisites

• Abbenay is installed. See Install Abbenay.
• At least one provider is configured. See Set up a local model with Ollama, Connect a cloud provider, or Connect Red Hat AI Inference.
• Your provider is running and accessible — for example, Ollama is started, or your cloud API key is valid.

Procedure

1. Start the Abbenay daemon:

   aby start

   Abbenay starts the daemon, web dashboard, OpenAI-compatible API, and MCP server on port 8787. A bearer token is generated automatically for HTTP API authentication.

2. Verify your configured models are available:

   aby list-models

   To see all supported engine IDs (not just configured models), run:

   aby list-engines

3. Optional — discover models available from a specific provider, including models not yet in your configuration:

   aby list-models --discover ollama
   aby list-models --discover redhat

4. Send a test prompt, using <provider>/<model> format:

   aby chat -m ollama/llama3.2

5. Type a test message and verify you receive a response. Press Ctrl+D to end the chat session.

Stop Abbenay

aby stop    # Stop all Abbenay services
aby status  # Check if Abbenay is running

Troubleshooting

Symptom	Cause	Resolution
aby list-models shows no models	Configuration file not found or malformed YAML	Verify your config.yaml path and syntax
Connection refused when chatting	Provider not running	Start your provider (for example, ollama serve, or verify your Red Hat AI endpoint is accessible)
401 Unauthorized	Missing or invalid API key	Verify your API key environment variable is set and matches the provider’s requirements
Model name not found	Incorrect model ID	Run aby list-models --discover <engine> to see available models, and use the exact ID in your config

Additional resources

• Abbenay configuration reference — full config.yaml documentation, security hardening, and engine reference
• Abbenay architecture — daemon design and component overview
• Abbenay product overview — architecture and positioning in the Ansible ecosystem
• Red Hat AI Inference documentation — RHEL AI endpoint setup
• Abbenay container guide — Kubernetes manifests, TLS, and security hardening
• Abbenay on GitHub — source repository, issues, and releases
• Our AI approach — how Abbenay fits alongside the MCP server, skills, and Lightspeed