aiac

AIAC implements a Backend interface abstraction layer that enables seamless switching between OpenAI, AWS Bedrock, and Ollama LLM providers through a single unified API. Each backend implementation satisfies the same interface contract, allowing the core library to invoke LLM calls interchangeably without provider-specific branching logic. This design pattern decouples the code generation logic from provider-specific API details, enabling new backends to be added by implementing the interface without modifying existing code.

AIAC provides a hierarchical configuration system using TOML files stored in XDG_CONFIG_HOME (~/.config/aiac/aiac.toml by default) that defines multiple named backends, each with provider type, credentials, and model defaults. The system supports environment variable overrides for sensitive credentials, allowing users to define backends in configuration while injecting secrets at runtime. Configuration loading follows a precedence chain: CLI flags > environment variables > TOML file defaults, enabling flexible deployment across local development, CI/CD, and containerized environments.

AIAC constructs domain-specific system prompts based on the target artifact type (Terraform, Dockerfile, Kubernetes, GitHub Actions, OPA, Bash, Python, SQL), guiding the LLM to generate syntactically correct and idiomatic code for each domain. Rather than using a generic system prompt, the tool embeds artifact-type-specific instructions that emphasize best practices, common patterns, and syntax requirements for each format. This enables a single LLM model to generate high-quality code across heterogeneous infrastructure domains without requiring separate specialized models.

AIAC integrates with AWS Bedrock by implementing the Backend interface for Bedrock's managed LLM service. The backend handles AWS authentication via IAM credentials, request formatting for Bedrock's API, and response parsing. Users can access multiple LLM providers (Anthropic Claude, Cohere, etc.) through Bedrock's unified API. This enables organizations with existing AWS infrastructure to leverage Bedrock without managing separate API accounts.

AIAC integrates with Ollama, an open-source tool for running LLMs locally. The Ollama backend implementation communicates with a local Ollama instance via HTTP API, enabling code generation without sending prompts to external services. Users can run open-source models (Llama 2, Mistral, etc.) locally, providing complete data privacy and no API costs. This backend is ideal for organizations with strict data governance requirements or offline environments.

AIAC accepts free-form natural language prompts describing infrastructure requirements and sends them to configured LLM backends with system prompts optimized for IaC generation. The system constructs prompts that guide the LLM to generate specific artifact types (Terraform, CloudFormation, Pulumi, Dockerfile, Kubernetes manifests, GitHub Actions, OPA policies, Bash/Python scripts, SQL queries). The LLM response is streamed back to the user and optionally formatted or saved to files, enabling rapid prototyping of infrastructure code without manual template writing.

After generating initial code, AIAC enters an interactive mode where users can refine, regenerate, or export the output. The CLI presents options to regenerate with the same prompt, modify the prompt and regenerate, save output to a file, copy to clipboard, or exit. This interactive loop enables iterative refinement of generated code without re-invoking the CLI, reducing context switching and allowing users to converge on acceptable output through multiple LLM invocations within a single session.

AIAC implements a dedicated OpenAI backend that communicates with OpenAI's API using the official Go SDK, supporting both GPT-3.5-turbo and GPT-4 models. The backend handles streaming responses, allowing real-time display of generated code as it's produced by the LLM rather than waiting for complete generation. It manages API authentication via OPENAI_API_KEY environment variable or configuration file, constructs system and user messages for IaC generation, and handles rate limiting and error responses from OpenAI's API.

AIAC implements an AWS Bedrock backend that abstracts multiple foundational models (Claude, Llama, Mistral, etc.) available through Bedrock's unified API. The backend handles AWS authentication via IAM credentials or assumed roles, constructs requests compatible with Bedrock's InvokeModel API, and manages model-specific request/response formats. This enables users to leverage Bedrock's managed model hosting without managing separate API keys for each provider, and to switch between models by changing configuration without code changes.

AIAC implements an Ollama backend that communicates with locally-running Ollama instances via HTTP API, enabling infrastructure code generation using open-source models (Llama 2, Mistral, etc.) without cloud API dependencies. The backend constructs HTTP requests to the Ollama API endpoint (default localhost:11434), handles model selection and parameter configuration, and streams responses from local models. This enables offline-capable infrastructure generation and eliminates per-token API costs, though at the cost of requiring local compute resources and managing model downloads.

AIAC provides a command-line interface that accepts natural language prompts and optional artifact type specifications (terraform, dockerfile, kubernetes, github-actions, opa, bash, python, sql, etc.) to guide code generation. The CLI parses arguments, loads configuration, selects the appropriate backend, constructs prompts with artifact-type context, and invokes the LLM. Users can specify artifact type explicitly or let the system infer from the prompt, enabling both guided and exploratory workflows from the terminal.

AIAC provides Docker image distribution enabling deployment as a containerized service without requiring local Go installation or configuration. The Docker image includes the compiled AIAC binary and can be invoked with environment variables for backend configuration, allowing infrastructure generation from containers in CI/CD pipelines, Kubernetes clusters, or other containerized environments. This enables AIAC integration into container-native workflows and eliminates dependency management for users.

AIAC exposes a Go library (libaiac package) enabling developers to embed infrastructure code generation directly into Go applications. The library provides functions to load configuration, select backends, and invoke code generation programmatically, allowing Go developers to build custom tools, web services, or automation that leverage AIAC's generation capabilities. This enables integration into larger Go-based infrastructure platforms without spawning CLI processes.