AI PowerShell Team with RAG

AIPSTeam

AIPSTeam is a PowerShell-first AI collaboration script that simulates a small delivery team around your project idea or existing script. Instead of giving you one raw answer, it helps produce a more structured first draft: requirements framing, implementation guidance, PowerShell output, documentation, and review-style feedback. It works with Azure OpenAI, Ollama, or LM Studio and is best approached through one clear first-run path before exploring the wider feature set.

Who this is for
Why use AIPSTeam
5-minute quickstart
What you get
Example first-run output
Representative example artifact
Recommended parameters
Supported environment
Known limitations
Advanced parameters
Overview
Retrieval-Augmented Generation (RAG)
Installation notes
Additional usage examples
Developer notes
Dependencies and prerequisites
Troubleshooting
FAQ

Who this is for

AIPSTeam is for:

PowerShell builders who want more than a single one-shot prompt
sysadmins and automation engineers who want AI-assisted project drafting
people who want code, documentation, and review-style output in one workflow

AIPSTeam is not the best fit for:

tiny one-line scripts
users who do not have any LLM backend configured
cases where fully production-ready output is expected from the first run without review

Why use AIPSTeam

Multi-role workflow: instead of one generic answer, the script simulates a team of specialists
PowerShell-first output: focused on PowerShell project work rather than generic coding chatter
Documentation and review included: useful when you want a first structured draft, not just raw code
Flexible backend choice: Azure OpenAI, Ollama, or LM Studio
Better first-pass thinking: useful when you want something closer to a draft delivery workflow than a single prompt completion

5-minute quickstart

1) Install required modules

Install-Module -Name PSAOAI
Install-Module -Name PSScriptAnalyzer
Install-Module -Name powerHTML

2) Install the script

Install-Script AIPSTeam

3) Configure one LLM backend

For the smoothest first run, use the backend you already have working.

Supported providers:

PSAOAI module repo:

PSAOAI

[!IMPORTANT] You need Azure OpenAI, Ollama, or LM Studio to use this script.

4) Run the recommended first demo

This is the canonical first-run path for understanding what AIPSTeam does. It keeps the workflow non-interactive and disables RAG so you do not need search-provider setup for the first pass.

$prompt = @"
Create a PowerShell tool that checks local administrator membership,
exports results to CSV, and generates basic documentation.
"@

$prompt | AIPSTeam.ps1 -LLMProvider "AzureOpenAI" -NOInteraction -NORAG -Stream $false

If you want the most completion-friendly path on heavier models, use the reduced workflow mode:

$prompt | AIPSTeam.ps1 -LLMProvider "AzureOpenAI" -NOInteraction -NORAG -ReducedWorkflow -Stream $false

If you are using another backend, switch only the provider value:

-LLMProvider "ollama"
-LLMProvider "LMStudio"

What you get

After a successful first run, you should expect output such as:

a clarified project goal or requirements summary
implementation ideas or proposed PowerShell structure
generated PowerShell code or code fragments
documentation draft content
review-style or QA-style feedback

The exact result depends on the model quality, available context window, and the prompt you provide.

[!IMPORTANT] The quality of the generated project depends significantly on the model used and the context window available. Better models and better context generally produce better drafts.

Example first-run output

A realistic first run will not usually give you a polished production-ready module. What it should give you is a strong working draft, for example:

Requirements summary
- Check local administrator membership
- Export results to CSV
- Produce basic usage documentation

Proposed implementation
- Collect local group membership
- Normalize account names and types
- Export results with timestamp
- Add basic error handling and documentation

Draft deliverables
- PowerShell code skeleton
- suggested function layout
- documentation outline
- reviewer notes / next improvements

That is the value of AIPSTeam: a more structured project draft than a single one-shot reply.

Representative example artifact

For a fuller walkthrough, see:

docs/first-run-example.md

That file shows a representative first-run scenario, the command used, the shape of the output, and what still needs human review.

Recommended parameters

These are the most useful parameters for a realistic first run:

userInput — project outline as a string; can also be piped
-NOInteraction — run without prompts or menus during the session
-ReducedWorkflow — run a smaller Manager + Developer flow that skips the heavier later stages
-LLMProvider — choose the backend: AzureOpenAI, ollama, or LMStudio
-NORAG — disable retrieval for a simpler first run
-Stream $false — disable streaming for a cleaner, easier-to-review result
-TheCodePath — work directly on an existing PowerShell script

Supported environment

Best-supported path

Windows PowerShell / PowerShell-focused workflow
one configured LLM backend only for the first run
non-interactive first pass with -NOInteraction -NORAG -Stream $false

Supported providers

Azure OpenAI
Ollama
LM Studio

Practical guidance

Start with the provider you already have working.
Start without RAG for the first run.
Treat Windows as the safest default path for now.
If you are on WSL/Linux or a mixed environment, expect more setup friction and verify the PSAOAI/runtime path first.

Known limitations

First-run output is a working draft, not a production-ready deliverable.
Result quality depends heavily on the selected model and available context window.
The smoothest path is to configure exactly one backend first and leave RAG off until the base flow works.
PSAOAI/runtime environment issues can be the main source of friction, especially outside the most typical Windows-oriented setup.
Advanced parameters are useful, but they are not the right starting point for understanding the tool.

Advanced parameters

Use these after the basic flow is already clear:

-Stream — enable or disable live streaming ($true by default)
-NOPM — disable Project Manager functions
-ReducedWorkflow — keep only the initial Manager → Developer pass and skip the later multi-review stages
-NODocumentator — disable Documentator functions
-NOLog — disable logging
-LogFolder — specify where logs should be stored
-DeploymentChat — override the Azure OpenAI deployment setting
-MaxTokens — control the length of generated responses
-NOTips — disable tips
-VerbosePrompt — show prompts
-LoadProjectStatus — resume from a saved project state
-NOUserInputCheck — disable the input check step

Overview

This PowerShell script simulates a team of AI agents working together on a PowerShell project. Each specialist has a role and contributes to the project in sequence. The script processes user input, performs different project tasks, and can generate outputs such as code, documentation, and analysis reports.

The main value of AIPSTeam is not just “generate some code,” but to move through a more structured multi-role flow that resembles requirements thinking, implementation, review, and documentation.

Retrieval-Augmented Generation (RAG)

RAG combines retrieval and generation to produce more accurate and contextually relevant outputs.

How it works:

Retrieval: the system fetches relevant external information.
Generation: the LLM uses that information to produce better output.

By integrating these two phases, AIPSTeam can produce more informed responses than a prompt-only flow.

Data source for RAG

AIPSTeam uses web search providers as a source for retrieval. Supported services include:

SerpApi — 100 free searches per month
EXA — 1000 free searches per month
Serper — 1000 free searches