aipack

• Video: AIPack Concept Video
• Video: Build Agent Getting Started Video Tutorial
• Video: Production Coding With pro@coder AI PACK
• Video: Example generate doc from code
• Video: pro@coder with pro@rust10x Rust best practices
• Video: AIPack Playlist

Quick Start

Install From Binaries

Mac, Linux, and Windows on ARM and x86 platforms are supported. See below for binary installation instructions.

(More info at aipack.ai/doc/install)

Mac

# Mac ARM / Apple Silicon
curl -O https://repo.aipack.ai/aip-dist/stable/latest/aarch64-apple-darwin/aip.tar.gz && \
        tar -xvf aip.tar.gz && \
        ./aip self setup

# Mac x86
curl -O https://repo.aipack.ai/aip-dist/stable/latest/x86_64-apple-darwin/aip.tar.gz && \
        tar -xvf aip.tar.gz && \
        ./aip self setup        

Linux

# Linux x86
curl -O https://repo.aipack.ai/aip-dist/stable/latest/x86_64-unknown-linux-gnu/aip.tar.gz && \
        tar -xvf aip.tar.gz && \
        ./aip self setup

# Linux ARM
curl -O https://repo.aipack.ai/aip-dist/stable/latest/aarch64-unknown-linux-gnu/aip.tar.gz && \
        tar -xvf aip.tar.gz && \
        ./aip self setup

Windows

# Windows x86
Invoke-WebRequest -Uri "https://repo.aipack.ai/aip-dist/stable/latest/x86_64-pc-windows-msvc/aip.tar.gz" -OutFile "aip.tar.gz"
tar -xvf aip.tar.gz
.\aip.exe self setup
     

# Windows ARM
Invoke-WebRequest -Uri "https://repo.aipack.ai/aip-dist/stable/latest/aarch64-pc-windows-msvc/aip.tar.gz" -OutFile "aip.tar.gz"
tar -xvf aip.tar.gz
.\aip.exe self setup

Install from source

For now, installation requires building directly from source with Rust. It works on all major OSes.

• Install Rust: https://www.rust-lang.org/tools/install
• For now, install with cargo install aipack

Run

# In the terminal, navigate to your project
cd /path/to/my/project/

# Initialize workspace .aipack/ and ~/.aipack-base
aip init

# Make sure to export the desired API key (no spaces around `=`; Unix convention)
export OPENAI_API_KEY="sk...."
export ANTHROPIC_API_KEY="...."
export GEMINI_API_KEY="..."
# For more keys, see below

# Check the keys you've set up
aip check-keys

# To proofread your README.md (namespace: demo, pack_name: proof):
aip run demo@proof -f ./README.md

# You can just use @pack_name if there is no other pack with that name
aip run @proof -f ./README.md

Install From Git

Install a pack directly from a Git repository. Use an explicit # selector when the pack is located in a repository subdirectory:

aip install git://git.example.com/team/example-pack.git

# with path to the pack dir
aip install git://git.example.com/team/example-pack.git#path/to/pack_dir

# with auth
aip install git+ssh://git@github.com/owner/example-pack.git#path/to/pack_dir

# or with the SCP way (the copy/paste from github for example)
aip install git@github.com:owner/example-pack.git

The repository portion before # is cloned. Without a selector, the cloned repository root must contain pack.toml. With a selector, the selected directory must contain pack.toml. The manifest's namespace and name fields determine the installed path under ~/.aipack-base/pack/installed/<namespace>/<name>.

Pack paths are selected only with an explicit # selector. A path after .git without # is not inferred as a pack path. Ordinary http:// and https:// links continue to be treated as downloadable .aipack archives.

Git installations resolve the checked-out commit and record its full hash as [installed].commit in the copied pack.toml. When a selected subpath is used, [installed].source retains the original Git URL and selector.

Thanks to

• Stephane Philipakis, a key aipack collaborator.
• savi0ur for PR #67 - ^ run - Add 'allow_run_on_task_fail' option
• Diaa Kasem for --non-interactive/--ni (Now, in v0.7.x -s or --single-shot) mode (#28)

pro@coder

• You can install pro@coder with aip install pro@coder, and then
• Run it with aip run pro@coder or aip run @coder if you don't have any other @coder pack in a different namespace.

This is the agent I use every day for my production coding.

IMPORTANT 1: Make sure everything is committed before use, especially while you are learning AIPack.

IMPORTANT 2: Make sure you have your API_KEY set as an environment variable. On macOS, there is experimental keychain support.

OPENAI_API_KEY
ANTHROPIC_API_KEY
GEMINI_API_KEY
DEEPSEEK_API_KEY
KIMI_API_KEY
ZAI_API_KEY
FIREWORKS_API_KEY
TOGETHER_API_KEY
NEBIUS_API_KEY
GROQ_API_KEY
COHERE_API_KEY
XAI_API_KEY

On mac, you can also use OMLX with for example

OMLX_ENDPOINT=http://127.0.0.1:8000/v1/

More Info

• Website: https://aipack.ai

• AIPack Overview Video

• Preview 'devai' intro video for v0.5

• Built on top of the Rust genai library, which supports many top AI providers and models (OpenAI, Anthropic, Gemini, DeepSeek, Groq, Ollama, xAI, and Cohere).

• See full CHANGELOG

How it works

• One Agent == One Markdown
  • An .aip agent file is just a Markdown file with sections for each stage of the agent's processing.
  • See below for all the possible stages.
• aip run demo@proof -f "./*.md"
  • will run the installed agent file main.aip in the
  • pack named proof
  • namespace demo
  • agent file main.aip
  • Full path ~/.aipack-base/pack/installed/demo/proof/main.aip
  • You can pass input to your agent using:
    • -f "path/with/optional/**/glob.*" -f "README.md" (the Lua code will receive a {path = .., name =..} FileInfo-like structure as input)
    • -i "some string" -i "another input" (the Lua code will receive these strings as input)
  • Each input triggers one run of the agent.
• aip run some/path/to/agent
  • If the path ends with .aip, it's treated as a direct file run.
  • If there is no .aip extension, then:
    • .../agent.aip will be executed if it exists.
    • or .../agent/main.aip will be executed if it exists.
• AIPack agents are simple .aip files that can be placed anywhere on disk.
  • e.g., aipack run ./my-path/to/my-agent.aip ...
• Multi AI Provider / Models - AIPack uses genai and therefore supports providers like OpenAI, Anthropic, Gemini, Groq, Ollama, Cohere, and more.
• Lua is used for all scripting (thanks to the great mlua crate).
• Handlebars is used for all prompt templating (thanks to the great Rust native handlebars crate).

Multi Stage

A single AIPack file may comprise any of the following stages.

• # Before All and # After All act like the map and reduce steps, running before and after the main input processing loop, respectively.

more info on stages

aipack doc

See the AIPack documentation at core/doc/README.md (with the Lua modules doc).

You can also run the ask-aipack agent.

# IMPORTANT: Make sure you have the `OPENAI_API_KEY` (or the key for your desired model) set in your environment.
aip run core@ask-aipack
# The prompt file will be at `.aipack/.prompt/core@ask-aipack/ask-prompt.md`

This Repo