Imagine asking an AI “What’s the weather in London, Paris, and Tokyo?” and watching it automatically call real functions, fetch live data, and give you formatted results. No hardcoded responses, no manual scripting – just intelligent function execution.

That’s exactly what we’re building today. Using just 7 lines of PowerShell and the PSAI framework, you’ll create an AI agent that can execute your existing functions, cmdlets, and APIs on demand.

Why This Matters: Most AI demos show chatbots that can only talk. This tutorial shows you how to build agents that can do – turning conversation into action.

Jump to the action → or set up your environment first →

Building the Weather Agent: From Function to AI in Minutes

Here’s the magic: Take any PowerShell function you’ve already written, pass it to an AI agent, and suddenly your function becomes conversationally accessible. No API wrappers, no complex integrations – just pure PowerShell power.

Let’s start with a simple weather function that calls a free weather API:

🚀 The PSAI Advantage

Use What You Already Have: PSAI works with your existing PowerShell functions, built-in cmdlets, and third-party modules. No rewrites, no wrappers – just instant AI integration.

Zero Learning Curve: If you know PowerShell, you know how to build AI agents. The framework does the heavy lifting.

The PowerShell Function: Just 7 Lines

This is all it takes. A basic PowerShell function that calls a weather API – nothing fancy, nothing complicated:

function global:Get-Weather {
    param(
        [string]$location
    )

    Invoke-RestMethod -Uri "http://wttr.in/$($location)?format=%l:+%c+%t+%h+%w+%p"
}

Test Drive: See It Work

Before we make it AI-powered, let’s see our simple function in action. Copy the function above into your PowerShell session and try it out:

Getting weather for multiple cities at once:

The Magic Moment: Function → AI Agent

Here’s where it gets interesting. With your Get-Weather function loaded in your PowerShell session, you’re one line away from an AI agent that can intelligently call it.

From simple function to conversational AI:

The One-Liner That Changes Everything

This single line transforms your function into a conversational AI:

New-Agent -Tools Get-Weather | Start-Conversation

The -Tools parameter specifies the functions or cmdlets that the agent can use during the conversation. It can take multiple tools as a comma-separated list. This gives your agent access to a variety of skill/capabilities. Start-Conversation begins the interaction with the agent.

This spins up a loop that listens for your input, passing it to the agent as a prompt, it includes the tool Get-Weather (converted to the function call schema for AI models).

AI determines from the prompt if an external function call is needed. The AI model does not call functions directly; instead, it generates a function call request that the agent framework interprets and executes. It does a remote procedure call, if you will, to the function. It informs the agent framework the name of the function to call, Get-Weather, and the parameters they need to be set and to what value location='nyc'.

The agent framework then executes the function and returns the result to the AI model, which determines if it has enough information to respond or if it needs to make additional function calls. In this case it has enough information and replies with the weather and conditins for New York City (note: the AI model turned 'nyc' into 'New York City').

Let’s dive deeper with a more complex example that shows the agent’s true intelligence.

Watch the AI Think: Behind-the-Scenes Function Calling

Want to see the magic happen? Add the -ShowToolCalls switch to watch your agent make decisions in real-time. You’ll see exactly when and how it chooses to call your functions.

The Beautiful Part: The agent doesn’t use hardcoded if/then logic. It genuinely understands when your functions are needed and figures out the right parameters to use.

Let’s Break It Down

The -ShowToolCalls parameter enables verbose output that reveals the agent’s “thought process.” Watch as it:

1. Analyzes your question
2. Decides which functions to call
3. Determines the right parameters
4. Executes multiple functions in parallel when needed

As the functions calls are executed, the results are returned to the AI model, which then decides if it has enough information to respond or if it needs to make additional function calls. When complete, the agent provides a final response.

### The “Agent Response” box

After all the function calls have been made, and the agent determines it has enough information, the agent compiles the details and presents a coherent response to the user.

Let’s do a follow-up question to see how the agent handles it.

The Follow-Up: AI Memory in Action

Here’s where it gets really impressive. Since we’re working with an AI agent, let’s test its reasoning abilities.

I asked: “Do I need a sweater or umbrella for any of them?”

Notice what happened:

✅ Memory: The agent remembers all previous weather data
✅ Context Awareness: It knows it doesn’t need new function calls
✅ Reasoning: It analyzes the existing data to provide practical advice

This is conversational AI that actually understands context.

Your Turn: What Will You Build?

The weather agent is just the beginning. With this foundation, you can create agents for any domain. Here are some ideas to get you started:

💡 Quick Wins You Can Try Right Now:

File System Agent – Give your AI eyes and hands for your files:

New-Agent -Tools Get-Content, Get-ChildItem -ShowToolCalls | Start-Conversation

Try asking:

• “What files do you see?” → Agent calls Get-ChildItem
• “Read config.json” → Agent calls Get-Content
• “Show me all .log files” → Agent intelligently filters results

🔥 Pro Tip: Add Set-Content to create a file-writing agent, but implement guardrails first!

Coming Next:

In my next post, I’ll show you how to build agents with write permissions while keeping you in control – including approval workflows and safety guardrails.

More Agent Ideas:

• System Monitor: Get-Process, Get-Service, Get-EventLog
• Git Helper: git status, git log, custom Git functions
• Database Query Agent: Your existing database functions
• API Integration Agent: Any REST API wrapper functions

The Future is Conversational Automation

You just learned something powerful: How to bridge the gap between AI conversation and real-world action. With PSAI, your existing PowerShell expertise becomes the foundation for intelligent automation.

What We Covered: ✅ Turning any PowerShell function into an AI-accessible tool
✅ Building agents that maintain context and memory
✅ Watching AI make intelligent decisions about when to call functions
✅ Creating practical automation that goes beyond simple chatbots

The Big Picture: This isn’t just about weather APIs. It’s about creating AI agents that can interact with your entire PowerShell ecosystem – your functions, your modules, your workflows.

Your automation just got conversational.

Getting Started: 5-Minute Setup

Ready to build your first AI agent? Here’s everything you need:

Step 1: Install PSAI (30 seconds)

Install-Module -Name PSAI 

⭐ Love this project? Star the repo: github.com/dfinke/PSAI

Step 2: Get Your OpenAI API Key (5 minutes)

Quick Setup:

1. Create Account: platform.openai.com → Verify email & phone
2. Add Billing: Minimum $5 (pay-as-you-go, no overages)
3. Generate API Key: platform.openai.com/account/api-keys

💰 Cost Reality Check: Basic testing costs pennies. The weather examples above cost less than $0.01 to run.

Step 3: Configure & Test (2 minutes)

Set your API key (add to your PowerShell $PROFILE):

$env:OPENAI_API_KEY = 'sk-proj-your_api_key_here'

Verify everything works:

New-Agent | Get-AgentResponse 'what is the capital of France?'

Expected output:

The capital of France is Paris.

🎉 Success! You’re ready to build AI agents that can execute real PowerShell functions.

Next: Copy the weather function from above and start building your first function-calling agent!

Imagine a world where you can seamlessly integrate AI with your cloud infrastructure—no complex setup, no extensive coding. Thanks to Model Context Protocols (MCPs), that world is becoming a reality.

Big tech companies are rolling out these integrations, allowing developers to automate tasks, streamline operations, and tap into the full potential of AI-powered workflows. In this post, I’ll dive deep into the MCPs offered by top players like AWS, Google, and Microsoft, giving you the tools you need to stay ahead of the curve.

Let’s explore how these integrations are revolutionizing cloud infrastructure and transforming the way developers work.

MCP-Servers-And-Integrations

As the adoption of MCPs accelerates, developers must stay on top of these integrations to leverage the full potential of AI in their cloud environments. The rise of MCPs is set to dramatically simplify the way we build, deploy, and manage cloud resources.

Whether you’re working with AWS, Microsoft Azure, or newer providers like Upstash and Neon, the future is about intelligent automation and seamless integration. Be sure to check out these integrations and start exploring how they can enhance your workflows.

Stay ahead of the curve and embrace the future of cloud computing powered by AI!

🚀 Turn ChatGPT into a Dashboard Generator Right Inside Your Favorite IDE — VS Code — with chatMode.md

Ever wish ChatGPT just knew how to build dashboards without having to spell it out every time?

With Custom Chat Modes in GitHub Copilot Chat for VS Code, now it can.

You define the personality and behavior — and Copilot does the rest. No wrappers. No extensions. Just a markdown file and your favorite IDE: VS Code.

Let me show you how I built a mode called 📊 Dashboard Bot — and how you can do the same in under 5 minutes.

🧠 What’s chatMode.md?

It’s a new feature in Copilot Chat (VS Code Insiders) that lets you define your own assistant personas.

Each .chatMode.md file becomes a selectable Copilot persona in the chat dropdown — complete with its own tone, purpose, and rules.

📊 Meet Dashboard Bot

Here’s the full dashboard-bot.chatmode.md:

---
description: "📊 Dashboard Bot"
---

You are a helpful assistant that specializes in creating dashboards.

You turn raw data (usually CSV or JSON) into clean, interactive dashboards using:
- **Single-file HTML** with embedded JavaScript (e.g., Chart.js)
- Optionally styled with Tailwind CSS
- Or React + Recharts if requested

Always ask the user:
- What kind of chart(s) they want (bar, line, pie, etc.)?
- What columns to visualize?
- If they want the output as a single-file HTML page or as a React component?

Your default is:
- A self-contained, single `.html` file with everything embedded
- Includes example data or explains how to load an external `.csv` or `.json` file
- No external build tools required

Your goals:
- Make dashboards easy to preview
- Keep the code clean and copy-pasteable
- Include usage notes or preview instructions when needed

Never overcomplicate it. Avoid frameworks unless explicitly requested.

Save that as dashboard-bot.chatmode.md, open Copilot Chat, and select “📊 Dashboard Bot” from the dropdown. Instantly, you’ve got a dashboard-savvy AI assistant at your command.

🎯 Setting Up Dashboard Bot Mode

Once you’ve created your dashboard-bot.chatmode.md file, here’s how to activate it:

1. Open the Copilot Chat panel in VS Code (if you haven’t already)
2. Look for the dropdown menu at the bottom of the chat panel
3. Click on the dropdown — you should see “📊 Dashboard Bot” as one of the options
4. Select it, and voilà! You’re now chatting with your specialized dashboard assistant

💡 Pro Tip: You can quickly switch between different modes using the dropdown, making it easy to context-switch between different specialized assistants.

🛠️ Top 5 Prompt Templates to Get Started

1. 🔨 Builder Template

“Create a single-file HTML dashboard template that reads data.csv from the same folder, uses Chart.js, and shows a bar chart. I’ll reuse it.”

2. 📈 Monthly Revenue Chart

“I have a CSV with Date and Revenue. Create a single HTML file with a bar chart showing monthly revenue.”

3. 🥧 Sales Breakdown

“CSV with Category and TotalSales. Build a pie chart dashboard showing sales by category.”

4. 📉 Multi-Series Line Chart

“Line chart with multiple lines — one per region — showing sales over time. Use Chart.js in a single HTML file.”

5. 📊 Table + Chart Combo

“Dashboard with both a data table and a bar chart. Columns: Product, Units Sold, Profit. Single HTML file.”

🧩 Why This Is a Game Changer

• No more repeating yourself
• Codify prompt behavior like code
• Paves the way for tool-augmented agents in the IDE

💬 What’s Next?

You could:

• Build a Security Reviewer that flags risky code
• Build a Rubber Duck mode that only asks clarifying questions
• Or plug into your own MCP toolchain and get real task automation

If you want a GitHub repo with reusable ChatModes, prompt packs, and template dashboards — ping me.

🗂️ Where to Put Your chatMode.md Files?

Your custom chat modes need to live in a specific location for VS Code to find them:

1. Workspace Settings:
   • Create a .vscode/chat-modes folder in your workspace
   • Place your .chatMode.md files there
   • Perfect for project-specific chat modes!
2. User Settings Location:
   • Windows: %APPDATA%\Code\User\globalStorage\github.copilot-chat\chat-modes
   • macOS: ~/Library/Application Support/Code/User/globalStorage/github.copilot-chat/chat-modes
   • Linux: ~/.config/Code/User/globalStorage/github.copilot-chat/chat-modes

Pro Tip: The workspace location is great for sharing chat modes with your team via source control.

⌨️ Quick Access via Command Palette

You can also manage your chat modes directly through VS Code’s Command Palette:

1. Press Ctrl+Shift+P (Windows/Linux) or Cmd+Shift+P (macOS)
2. Type “Chat:”
3. Look for these commands:
   • Chat: New Mode File
   • Chat: Set Chat Mode
   • Chat: Configure Chat Modes

This is the fastest way to create, edit, and switch between your custom chat modes!

🎯 Conclusion

The power of custom chat modes in GitHub Copilot Chat represents a significant leap forward in how we interact with AI assistants. Dashboard Bot is just one example of how we can specialize these tools for specific tasks, making our development workflow more efficient and focused.

By creating your own .chatMode.md files, you can build AI assistants that perfectly match your needs – whether that’s for dashboard creation, API testing, documentation writing, or any other specialized development task.

The beauty of this approach lies in its simplicity: no complex setups, no external dependencies, just a markdown file that transforms Copilot into your perfect coding companion. As we continue to explore the possibilities of AI-assisted development, custom chat modes will undoubtedly become an essential tool in every developer’s toolkit.

So, what specialized AI assistant will you create?

Happy Dashboarding! 📊✨

🤝 Stay Connected

• X - @dfinke
• LinkedIn - douglasfinke
• YouTube - @DougFinke
• GitHub - dfinke
• Blog - dfinke.github.io

One Idea, One Prompt — Watching GitHub Copilot Code Agent Work in Real Time

I’ve been experimenting with the new GitHub Copilot Code Agent. It’s early, but you can already feel where this is going.

The flow is straightforward:

1. I create a GitHub Issue describing a task.
2. I assign it to Copilot.
3. It creates a branch, opens a PR, and triggers a GitHub Action.

You can watch the work unfold, piece by piece. But here’s the thing:

I had to keep flipping tabs.

• One to check the PR
• Another to check the Actions tab
• Click, scroll, refresh
• Repeat

It felt like exactly the kind of friction an agent is supposed to remove.

The Original Itch

So I had the idea: I want a live dashboard.

• One screen.
• On the left: PRs.
• On the right: Workflow runs.
• Updated every 15 seconds. No reloads. No tab switching.

That was part of the original itch—the vision of how this should feel. If we’re going to work with agents, we should have tools that show the agency happening.

The Prompt

I didn’t overthink it. I spun up a completely separate project in VS Code, Copilot enabled. Different repo, fresh folder. Just UI.

And I prompted:

“Create an HTML dashboard that shows all open PRs and their GitHub Actions status. Refresh every 15 seconds.”

That was it.

The Result

Copilot built the whole thing—HTML, JavaScript, CSS. Used the GitHub API. I plugged in my repo name and a token, saved, and it ran.

And it just worked.

• PRs are listed on the left.
• Workflow runs on the right.
• Auto-refreshes every 15 seconds.
• I can see the agent’s progress in real time.

It’s not fancy. It’s not meant to be.

But it’s exactly what I wanted, and all from a single prompt. I didn’t write a line of code for the dashboard itself and it just works.

The Shift

This is how things are changing:

• I didn’t build a dashboard. I had the idea and prompted for it.
• I didn’t wire up backend APIs. The agent did it.
• I didn’t switch contexts. I created one.

From building to orchestrating. From tabs to tasks.

The future of development isn’t just AI writing code—it’s reshaping how we observe and direct code being written. The dashboard I prompted into existence is as much about visibility as it is about agency.

And that’s the deeper shift.

What’s Next?

• What if the dashboard had a button to reassign failed runs?
• What if it visualized issue threads as intent containers?
• What if it prompted me when something needed attention?

This is barely day one.

Agents aren’t just coding—they’re reshaping the workflows around code. And we’re just getting started.

Get the Code

Want to try this dashboard yourself? I’ve made the code available in my GitHub repository: github-status-dashboard. Feel free to fork it, modify it, and make it your own.

To get started:

1. Clone the repository
2. Add your GitHub token
3. Update the repository name
4. Open the HTML file in your browser

The code is intentionally simple and straightforward - exactly as it was generated from the prompt. It serves as a great starting point for your own customizations and improvements.

Connect with Me

Have you ever hit a surprising result in PowerShell where functions inside a loop don’t behave like you expect? Let’s dig into this classic gotcha.

Here’s the snippet:

$funcs = @()

foreach ($i in 1..3) {
    $funcs += { $i }
}

Write-Host (($funcs | ForEach-Object { &$_ }) -join ', ')

The quiz gives four possible outcomes:

A. 0, 1, 2  
B. 1, 2, 3  
C. 3, 3, 3  
D. Error  

🔍 Step-by-Step Breakdown

Step 1: Initializing the array

$funcs = @()

We’re setting up an empty array to hold script blocks (PowerShell’s anonymous functions).

Step 2: The loop

foreach ($i in 1..3) {
    $funcs += { $i }
}

This adds three script blocks to the array. Each of them references the variable $i.

But here’s the catch: PowerShell closures capture the variable, not its current value. By the time the loop finishes, $i equals 3. So all three script blocks return 3 when invoked.

Step 3: Executing the script blocks

$funcs | ForEach-Object { &$_ }

We run each script block. Since they all reference the same $i, they all return 3.

Step 4: Joining the output

-join ', '

Result:

3, 3, 3

✅ Correct Answer: C. 3, 3, 3

🛠 The Fix: Capture the value, not the reference

PowerShell gives you a built-in way to capture the current value of a variable into a closure:

foreach ($i in 1..3) {
    $funcs += { $i }.GetNewClosure()
}

Now each script block holds onto its own snapshot of $i.

So this:

Write-Host (($funcs | ForEach-Object { &$_ }) -join ', ')

will output:

1, 2, 3

🧠 Takeaway

Closures are powerful, but they can surprise you. Remember:

In PowerShell, { $i } captures the variable — not the value. Use .GetNewClosure() to freeze the value at that moment.

Got more PowerShell puzzles? Drop them in the comments or join the NYC PowerShell Meetup!

Introduction

In today’s fast-paced IT landscape, automation is no longer a luxury but a necessity. As PowerShell continues to be the backbone of Windows administration, integrating artificial intelligence (AI) into scripting can significantly enhance productivity. Enter PSAI, the PowerShell AI module—a powerful tool that streamlines automation, scripting, and command execution using AI-driven assistance.

The Evolution of PowerShell and AI

PowerShell has evolved from a simple scripting language into a robust automation platform. The integration of AI tools like OpenAI models into PowerShell scripting has unlocked new efficiencies, making it easier than ever to generate scripts, analyze logs, and troubleshoot systems. PSAI takes this concept further by embedding AI-powered assistance directly into the PowerShell environment. By leveraging natural language processing (NLP), it allows administrators and developers to describe tasks in plain English and receive functional PowerShell code in response.

Getting Started with PSAI

PSAI is designed to be easily integrated into any PowerShell environment. Installing it is straightforward: Install-Module -Name PSAI Once installed, users can begin leveraging AI to assist with various administrative and development tasks.

Obtaining an OpenAI API Key

To fully utilize PSAI, users need an OpenAI API key. Obtaining a key is a simple process:

1. Visit OpenAI’s API platform.
2. Sign up for an account or log in if you already have one.
3. Navigate to the API section and generate a new API key.
4. Store the key securely, as it will be required for authentication. OpenAI’s API operates on a credit-based system, and it is safe to use a credit card to purchase API credits. OpenAI provides transparency in usage, ensuring that users only pay for what they consume.

Key Features of PSAI

AI-Generated Scripting

Gone are the days of painstakingly writing PowerShell scripts line by line. PSAI empowers users with the ability to dynamically generate scripts tailored to their needs. Take the example below. In response to a query like q ‘what is my ip’, PSAI leverages its AI-driven capabilities to suggest the appropriate command:

The tool goes beyond merely generating the command. It provides actionable next steps to streamline your workflow, such as copying the command to the clipboard for immediate use. This approach saves time, reduces errors, and enhances productivity for both seasoned professionals and beginners alike. PSAI’s AI-driven scripting allows users to bypass manual research, focusing instead on implementing solutions directly.

Follow-Up with Contextual Awareness

What sets PSAI apart is its ability to retain conversational context, much like a chat assistant. The “Follow Up” feature ensures that subsequent queries build on prior interactions, enabling a more cohesive and intuitive experience. For instance, if you run a command and then ask for additional steps or refinements, PSAI can interpret your request in context without requiring repetitive input. This memory-like functionality significantly reduces the cognitive load on users, allowing them to focus on outcomes rather than the intricacies of scripting.

Seamless Contextual Refinements

PSAI truly shines when users need to refine their queries or add qualifying information. With its ability to retain context, PSAI can provide intelligent follow-ups without requiring redundant explanations. For instance:

1. The user asks, q ‘processes using more than 800 handles’. PSAI generates the PowerShell.
2. The user then asks for additional refinement: owned by Microsoft. PSAI understands the context and modifies the command.

This example highlights PSAI’s ability to adapt dynamically to follow-up questions, saving users time and effort by maintaining a thread of understanding throughout the interaction. Such contextual awareness elevates the scripting experience, making it both intuitive and efficient.

Automated Reporting Made Effortless

PSAI also simplifies tasks that typically require detailed knowledge of PowerShell scripting. For example, to generate a report of all users with administrative privileges and export it to a CSV file, the user can simply ask.

PSAI instantly provides the appropriate command. This feature is invaluable for automating administrative tasks, enabling users to generate reports or handle complex operations with minimal effort. Once again, the “Follow Up” functionality remains available, allowing users to refine the output further if necessary.

Autonomous Agents for Complex Workflows

One of PSAI’s most powerful features is the ability to create autonomous agents for performing complex workflows. Using the New-Agent cmdlet, users can define agents equipped with specific tools, instructions, and verbose logging for advanced control.

Consider the following scenario:

Here’s what makes this remarkable:

1. Agent Creation: The New-Agent cmdlet creates an agent capable of leveraging the New-TavilyAITool for web searches.
2. Instructions: A string, interpolated using PowerShell’s syntax, passes dynamic information (e.g., the current date) to the agent.
3. Verbose Logging: With -ShowToolCalls, PSAI provides visibility into the AI’s decision-making process. In this example, the VERBOSE output reveals the specific functions (Invoke-WebSearch) and parameters used.

As the workflow unfolds, the AI evaluates the results of each web search, determining whether further steps are needed or if it can conclude. The final output is a structured report of U.S. job numbers over the last three Decembers, automatically aggregated and presented for the user.

The Future of AI in PowerShell Automation

The integration of AI into PowerShell through tools like PSAI marks a turning point in how professionals approach scripting, automation, and complex workflows. The ability to generate scripts dynamically, retain conversational context, and refine outputs on the fly has already transformed productivity for many users. However, the introduction of autonomous agents takes this potential to the next level.

With features like New-Agent, users can create intelligent, task-specific agents equipped with tools and instructions to handle intricate, multi-step operations autonomously. These agents can interpret high-level directives, leverage external tools (like web searches), and dynamically adjust their workflows based on the results they retrieve. This combination of AI-driven intelligence and automation empowers users to tackle complex scenarios with minimal manual intervention.

As PSAI continues to evolve, its capacity for integrating advanced AI capabilities, such as better decision-making, real-time contextual awareness, and enhanced transparency through verbose logging, will only grow. This future of AI in PowerShell is not just about automation—it’s about creating intelligent systems that collaborate with users to solve problems efficiently and effectively.

Conclusion

PSAI represents a paradigm shift in PowerShell automation, blending traditional scripting capabilities with cutting-edge AI-driven functionalities. From dynamically generating scripts to refining complex queries and deploying autonomous agents, PSAI enables users to achieve unprecedented levels of efficiency and accuracy.

The examples highlighted in this article demonstrate PSAI’s versatility: automating administrative reporting, refining contextual queries, and managing intricate workflows with autonomous agents. These features empower IT professionals, system administrators, and developers to focus on solving problems rather than getting bogged down in the mechanics of scripting.

As we embrace this new era of AI-powered automation, tools like PSAI will play a pivotal role in reshaping how we interact with technology. The future is here, and it’s making PowerShell more powerful, intuitive, and indispensable than ever before.

As developers, we’re always looking for ways to write cleaner, more efficient code. One of the paradigms that facilitate this is functional programming, which emphasizes the use of functions and immutability. While PowerShell is primarily an object-oriented scripting language, it also supports functional programming concepts. Recently, I implemented a custom map function in PowerShell to process multiple arrays in a functional style. In this blog post, I’ll walk you through the implementation and show you how it can be used to simplify your data processing tasks.

The Need for a ‘map’ Function in PowerShell

In languages like Python and JavaScript, the map function is a staple for transforming data collections. It applies a given function to each item of a list and returns a list of the results. While PowerShell has cmdlets like ForEach-Object, they don’t natively support mapping over multiple arrays simultaneously. To bridge this gap, I created a custom map function that can apply a function to multiple arrays in parallel.

The Implementation

Here’s the core of the map function:

function map {
    param(
        $func, 
        [Parameter(ValueFromRemainingArguments = $true)] 
        $arrays
    )

    # Ensure all arrays are of the same length
    $arrays | ForEach-Object {
        if ($arrays[0].Length -ne $_.Length) {
            throw "All arrays must be of the same length"
        }
    }

    $dataType = $arrays.GetType().Name

    if ($dataType -eq "Object[]") {
        # If arrays are simple objects, apply the function directly
        $arrays | ForEach-Object {
            & $func $_
        }
    } 
    elseif ($dataType -eq 'List`1') {
        # If arrays are lists, process them in parallel
        $arrayCount = $arrays.Count
        $count = $arrays[0].Length

        # Get the parameter names of the function
        if ($func -is [scriptblock]) {
            $funcParams = $func.Ast.ParamBlock.Parameters | ForEach-Object { $_.Name.VariablePath.UserPath }            
        }
        else {
            $funcParams = (Get-Command $func).Parameters.Keys -as [array]
        }

        # Iterate over each index and apply the function
        for ($i = 0; $i -lt $count; $i++) {            
            $funcSplat = [ordered]@{}
            for ($ac = 0; $ac -lt $arrayCount; $ac++) {
                $funcSplat["$($funcParams[$ac])"] = $arrays[$ac][$i]
            }

            & $func @funcSplat
        }
    }
}

Key Features

• Parallel Processing: The function can take multiple arrays and apply a user-defined function to corresponding elements.
• Dynamic Parameter Handling: It extracts parameter names from the provided script block or function, allowing for flexible argument passing.
• Type Handling: It checks the data type of the input to ensure proper processing, distinguishing between simple arrays and lists.

Usage Example

Let’s see how this function works with a practical example. Suppose we have three arrays containing names, ages, and locations:

$who   = 'John', 'Jane', 'Doe', 'Smith'
$age   = 20, 30, 40, 50
$where = 'New York', 'California', 'Texas', 'Florida'

We can use the map function to combine these arrays into custom objects:

map {
    param($who, $age, $where)

    [PSCustomObject][Ordered]@{
        Name     = $who
        Age      = $age
        Location = $where
    }
} $who $age $where

Output:

Name  Age Location   
----  --- --------   
John   20 New York   
Jane   30 California 
Doe    40 Texas      
Smith  50 Florida    

The map function applies the script block to each set of elements from the arrays ($who[$i], $age[$i], $where[$i]) and constructs a custom object with the combined data.

How It Works

1. Parameter Extraction: The function retrieves the parameter names from the provided script block using the Abstract Syntax Tree (AST).
2. Length Verification: It checks that all input arrays are of the same length to avoid index out-of-range errors.
3. Function Invocation: It uses a loop to iterate over the index of the arrays and splats the parameters into the function for each iteration.

Benefits

• Enhanced Readability: By abstracting the iteration logic, the map function allows you to focus on the transformation logic.
• Reusability: You can use the map function with any number of arrays and any processing logic encapsulated in a script block or function.
• Functional Programming Style: This approach promotes immutability and pure functions, which can lead to fewer side effects and easier debugging.

Conclusion

The custom map function brings the power of functional programming’s map operation to PowerShell, enabling parallel processing of multiple arrays with ease. By leveraging script blocks and parameter extraction, it provides a flexible tool for data transformation tasks.

If you often find yourself processing multiple related arrays, consider adding this map function to your toolkit. It can simplify your scripts and make your code more expressive and maintainable.

Happy scripting!

The Evolution of Search Engines: From Archie to OpenAI Search

The story of search engines is a journey of constant innovation and transformation. It began in 1990 with Archie, a tool that allowed users to search filenames from FTP sites, laying the groundwork for indexing content online. Since then, search engines have evolved drastically, moving from simple keyword-based searches to AI-driven, context-aware experiences. Let’s explore this fascinating evolution and how it has shaped our interaction with the web.

1990: Archie - The First Step

In 1990, Archie became the first search engine, indexing filenames from FTP sites. Although rudimentary by today’s standards, Archie introduced the concept of indexing digital content, making it searchable. This marked the very beginning of our journey towards organizing the vast amount of information on the internet.

1991-1992: Gopher and Veronica - Organizing Content

The early ’90s brought Gopher, a protocol for organizing documents, and Veronica, a search tool for Gopher’s content. Together, they advanced the idea of searchable, organized web content, giving users more structure as they navigated the expanding web. It was the beginning of a more user-friendly approach to finding information.

1995: Altavista - Speed and Power

In 1995, Altavista set new standards for speed and search capabilities. It offered advanced search options and multilingual support, making it one of the first engines that truly focused on delivering fast and accurate results. Altavista was revolutionary, shaping the expectations of what a search engine could be.

1996: Ask Jeeves - Natural Language Queries

Ask Jeeves, launched in 1996, took a different approach by allowing users to input queries in natural language. It emphasized ease of use and intuitive question-answer interactions. Ask Jeeves introduced the idea that search engines should feel conversational and accessible, paving the way for the user-friendly interfaces we now take for granted.

1998: Google - The Game Changer

In 1998, Google changed everything. With its PageRank algorithm, which prioritized pages based on backlinks, Google transformed how we think about search relevance. The clean, minimalistic interface was a stark contrast to other search engines, and it quickly became the most popular choice for users. Google’s focus on delivering the most relevant results set a new benchmark for the industry.

2004: Yahoo Search - Attempting to Compete

By 2004, Yahoo had developed its own search engine after initially using Google for results. While Yahoo made attempts to compete with Google, it struggled to maintain user preference. Despite its efforts, Yahoo could not keep up with Google’s rapid growth and influence.

2009: Bing - User-Centric Features

Microsoft’s Bing, launched in 2009, offered a fresh perspective on search. Bing integrated features like cashback for shopping, visual search, and strong image integration, creating a more engaging user experience. It managed to carve out its own niche, focusing on visual appeal and user-centric functionalities.

2024: OpenAI Search (ChatGPT) - The AI Revolution

The latest milestone in search evolution is OpenAI Search, integrated with ChatGPT. Launched in 2024, this AI-driven search engine represents a significant shift towards real-time web search, conversational interaction, and source attribution. Unlike traditional search engines, OpenAI Search offers context-aware answers and an interactive, conversational experience. It’s not just about providing links anymore; it’s about understanding the intent behind a query and delivering a seamless, personalized information journey.

The Future of Search: An Interactive Experience

From Archie’s simple indexing to OpenAI Search’s sophisticated, conversational AI, search engines have continually evolved to better meet our needs. to better meet our needs. Today, with OpenAI Search, the user experience is no longer static; it’s an interactive, AI-driven journey that understands context and provides real-time insights. As we look ahead, it’s exciting to imagine where search will go next—continuing to transform, adapt, and redefine how we access information.

Let’s Stay Connected

• YouTube Channel
• Twitter
• LinkedIn

Analyzing Changes: A PowerShell Approach using Excel for Data Visualization

• Overview: In today’s data-driven environment, analyzing and visualizing data changes over time is critical for informed decision-making. This article explores a concise PowerShell script designed to process monthly data and output it into an Excel file, enhancing our ability to interpret changes effectively.

• Importance: With organizations increasingly reliant on data for strategic insights, the ability to quickly visualize performance metrics has never been more essential. PowerShell offers a robust platform for automating data manipulation tasks, enabling analysts to focus on interpretation rather than routine processing.

Understanding the Monthly Data

• Data Input: The PowerShell script begins by defining monthly data changes between two consecutive years (2023 and 2024). Each month has associated values representing performance, allowing users to observe trends and shifts in metrics.

• Data Structure: The code utilizes a simple CSV format read directly into a PowerShell object, making it easy to manipulate and export to other formats.

• Comparative Analysis: Change percentages are calculated for each month using the provided values, facilitating a quick assessment of whether performance is trending up or down year-over-year.

Exporting Data to Excel

• Excel File Creation: The script initializes an Excel file, ensuring any existing file is removed beforehand. This is crucial for maintaining up-to-date reports without manual intervention.

• Data Exporting: By leveraging the Export-Excel cmdlet, the script seamlessly transfers the monthly data into an Excel worksheet, formatted for clarity and ease of use.

• Formatting for Readability: The script applies formatting rules to enhance the presentation of data, such as bold text and background colors, thus improving user engagement with the Excel output.

Enhancing Output with Formatting

• Color-Coded Changes: The script employs customized cell formatting to signify increases and decreases in performance visibly. Positive changes are indicated with green, while negative changes appear in red, allowing for at-a-glance assessments of trends.

• Number Formatting: Utilization of custom number formats within Excel allows for easy interpretation of percentage changes, making it straightforward to discern significant fluctuations.

• Final Touches: The script automatically sizes columns and opens the Excel package for immediate review, maximizing user convenience and operational efficiency.

Code Explanation

The provided PowerShell script efficiently processes and visualizes monthly performance data in Excel, demonstrating key functionalities and strategies for automation:

$data = ConvertFrom-Csv @"
Month,2023YR,2024YR,Change
Jan,1000,1100,0.10
Feb,1200,1150,-0.0417
Mar,1500,1600,0.0667
Apr,1300,1250,-0.0385
May,1400,1500,0.0714
Jun,1600,1700,0.0625
Jul,1700,1650,-0.0294
Aug,1800,1800,0
Sep,2000,1950,-0.0250
Oct,2100,2200,0.0476
Nov,2200,2200,0
Dec,2300,2400,0.0435
"@

• Data Import: The script uses ConvertFrom-Csv to read the given inline CSV data, which represents monthly performance metrics over two distinct years.

$xlfile = "$PSScriptRoot\spike.xlsx"
Remove-Item $xlfile -ErrorAction SilentlyContinue

• File Management: It specifies the Excel file location and ensures that any previous versions are deleted, preventing potential errors during export.

$xlPkg = $data | Export-Excel -Path $xlfile -AutoSize -PassThru -StartRow 3 -StartColumn 4

• Exporting Data: The Export-Excel cmdlet takes the data and formats it into an Excel sheet, managing layout parameters such as row and column starts.

Set-ExcelRange -Worksheet $xlPkg.Sheet1 -Range "D3:G3" -Bold -BackgroundColor LightGreen -HorizontalAlignment Center
Set-ExcelRange -Worksheet $xlPkg.Sheet1 -Range "D4:D15" -Bold -BackgroundColor LightBlue -HorizontalAlignment Center

• Cell Formatting: Subsequent lines format specific ranges, enhancing readability with color cues and centralized text.

Set-ExcelRange -Worksheet $xlPkg.Sheet1 -Range "G3:G15" -NumberFormat "[color10]0.0#%▲;[red]0.0#%▼;[blue]0.0#% ▬" -AutoSize
Close-ExcelPackage $xlPkg -Show

• Final Adjustments: The final adjustments set the number format for percentage changes, ensuring that visual cues clearly indicate trends before opening the file for review.

Check Out the Video Tutorial

From Raw Data to Insights: PowerShell-Driven Excel Magic. Watch the video below to see the script in action and learn how to visualize monthly changes effectively.

Conclusion

• Summary: The article showcases a PowerShell script that not only processes and exports monthly data into a formatted Excel file but also highlights how quick visualization can significantly aid in data analysis.

• Implications: Such automation tools empower data analysts to make more informed decisions swiftly, as accessibility to visual data trends can improve responsiveness to market changes.

Harnessing PowerShell with OpenAI: An In-Depth Look at Audio Integration

• Overview: In an age where artificial intelligence transforms various domains, integrating AI functionalities into scripting languages opens new avenues for automation. One interesting use case involves using PowerShell to convert text into audio by leveraging OpenAI’s API. This article delves deep into the underlying code, its functionality, and its implications in the tech landscape.

• Importance: As OpenAI’s text-to-speech capabilities become increasingly robust and accessible, the ability to implement these features via PowerShell presents a powerful tool for developers and businesses alike. This capability allows for automation in creating audio content, enhancing accessibility, and providing innovative user experiences.

Understanding the Code

The following PowerShell script illustrates how to utilize OpenAI’s API to convert text into speech:

$prompt = "Recite first few lines of the Gettysburg Address" 

$headers = @{"Content-Type" = "application/json"; "Authorization" = "Bearer $($env:OpenAIKey)" }

$body = [ordered]@{
    model      = "gpt-4o-audio-preview"
    modalities = @("text", "audio")
    audio      = @{ voice = "nova"; format = "wav" } # alloy, echo, fable, onyx, nova, shimmer
    messages   = @(@{ role = "user"; content = $prompt })
}

$params = @{
    Uri     = "https://api.openai.com/v1/chat/completions"
    Method  = "Post"
    Headers = $headers
    Body    = ($body | ConvertTo-Json)
}

$result = Invoke-RestMethod @params

$wavDataBytes = [Convert]::FromBase64String($result.choices[0].message.audio.data )
$wavPath = "$PSScriptRoot\output.wav"

[System.IO.File]::WriteAllBytes($wavPath, $wavDataBytes)

Invoke-Item $wavPath

• The script begins by defining a prompt, asking OpenAI to recite the first few lines of the Gettysburg Address.
• Headers are established to communicate with the API, including content type and authorization using an API key stored in the environment.
• The body of the request is carefully structured to specify the model, modalities (text and audio), the voice to be used, and the conversation context.

Script Workflow

• The API endpoint is defined, and a POST request is launched using the Invoke-RestMethod cmdlet. This command sends the structured request to OpenAI’s server.
• The result from the API call is captured, extracting the audio data from the response.
• Finally, the audio data is decoded from its base64 format and saved as a WAV file on the local machine. The output file is then automatically opened for playback.

Benefits of PowerShell with OpenAI

• Accessibility: By employing PowerShell, a common tool for system administrators, AI features become more accessible without the need for extensive programming knowledge.
• Automation: Organizations can automate content creation, enabling diverse applications like generating audiobooks, announcements, and accessibility tools for visually impaired users.
• Cross-Platform Use: PowerShell’s compatibility with various environments means developers can implement OpenAI features seamlessly, enhancing their existing workflows.

Code Explanation

The provided script exemplifies a practical blend of PowerShell’s functionality with OpenAI’s capabilities. It demonstrates the basics of composing a structured API request, proper handling of JSON data, and the manipulation of binary audio data directly from a response. Each component of the script is modular, allowing users to adapt the prompt and configuration settings for different outputs or projects.

Conclusion

• Summary: This exploration of PowerShell’s integration with the OpenAI API emphasizes the simplicity and potential of automating audio content generation. The provided code serves as a foundational example that can be expanded or modified for various applications.
• Implications: As AI technologies continue to evolve, combining them with traditional scripting languages like PowerShell will enable greater innovations in content delivery, user engagement, and automation. This trend is likely to shape how organizations approach audio content creation in the future.

References

• PowerShell module for OpenAI API. PSAI - GitHub
• OpenAI Audio Generation