Generative AI Scripting

Prompting is Coding

Programmatically assemble prompts for LLMs using JavaScript. Orchestrate LLMs, tools, and data in a single script.

JavaScript toolbox to work with prompts
Abstraction to make it easy and productive
Seamless Visual Studio Code integration

Hello world

Say to you want to create an LLM script that generates a ‘hello world’ poem. You can write the following script:

$`Write a 'hello world' poem.`

The $ function is a template tag that creates a prompt. The prompt is then sent to the LLM (you configured), which generates the poem.

Let’s make it more interesting by adding files, data, and structured output. Say you want to include a file in the prompt, and then save the output in a file. You can write the following script:

// read files
const file = await workspace.readText("data.txt")
// include the file content in the prompt in a context-friendly way
def("DATA", file)
// the task
$`Analyze DATA and extract data in JSON in data.json.`

The def function includes the content of the file, and optimizes it if necessary for the target LLM. GenAIScript script also parses the LLM output and will extract the data.json file automatically.

Next steps

Listen to the podcast

Install the extension

Install the Visual Studio Code Extension to get started.

Configure your LLMs

Configure the secrets to access your LLMs.

Write your first script

Follow Getting Started to write your first script.

Read the docs

Learn more about GenAIScript in the Scripting Reference.

A screenshot of VSCode with a genaiscript opened

Features

GenAIScript brings essential LLM prompt tooling into a cohesive scripting environment.

Stylized JavaScript

Minimal syntax to build prompts using JavaScript or TypeScript.

$`Summarize ${env.files}. Today is ${new Date()}.`

Fast Development Loop

Edit, Debug, Run, Test your scripts in Visual Studio Code or with a command line.

A screenshot of a debugging session in a code editor with a breakpoint set on a line of code. The editor is displaying several panels including the watch variables, call stack, and a terminal output. The code is partially visible with a function definition and JSON configuration data.

LLM Tools

defTool("weather", "live weather",
    { city: "Paris" }, // schema
    async ({ city }) => // callback
        { ... "sunny" }
)

or use @agentic tools

import { WeatherClient } from "@agentic/weather"
defTool(new WeatherClient())

Model Context Provider Client

Use tools exposed in MCP Servers

defTool({ "memory": {
    command: "npx",
    args: ["-y", "@modelcontextprotocol/server-memory"]
}})

LLM Agents

Combine tools and inline prompts into an agent.

defAgent(
    "git",
    "Agent that answer git questions for the current repo",
    "You are a helpful expert in using git.",
    { tools: ["git"] }
)

script({ tools: "agent" })

$`Do a statistical analysis of the last commits`

Reuse and Share Scripts

Scripts are files! They can be versioned, shared, forked, …

Directorygenaisrc
- my-script.genai.mjs
- another-great-script.genai.mjs

Data Schemas

Define, validate, repair data using schemas.

const data = defSchema("MY_DATA",
    { type: "array", items: { ... }, })
$`Extract data from files using ${data} schema.`

Ingest text from PDFs, DOCX, ...

Manipulate PDFs, DOCX, …

// automatically convert to text
def("PDF", env.files, { endsWith: ".pdf" })
// or parse and process
const { pages } = await parsers.PDF(env.files[0])

Ingest tables from CSV, XLSX, ..

Manipulate tabular data from CSV, XLSX, …

// automatically convert to text
def("DATA", env.files, {
    endsWith: ".csv",
    // take top 100 rows
    sliceHead: 100,
})
// or parse to JavaScript object array
const rows = await parsers.CSV(env.files[0])
// render as markdown table
defData("ROWS", rows, { sliceHead: 100 })

Generate Files

Extract files and diff from the LLM output. Preview changes in Refactoring UI.

$`Save the result in poem.txt.`

FILE ./poem.txt
```txt
The quick brown fox jumps over the lazy dog.
```

poem.txt extracted by genaiscript

File search

Grep or fuzz search files

const { files } = await workspace.grep(/[a-z][a-z0-9]+/, { globs: "*.md" })

Web search

Web search using Bing or Tavily.

const pages = await retreival.webSearch("what are the latest news about AI?")

Browser automation

Browse and scrape the web with Playwright.

const page = await host.browse("https://...")
const table = await page.locator("table[...]").innerHTML()
def("TABLE", await HTML.convertToMarkdown(table))

RAG built-in

Vector search.

const { files } = await retrieval.vectorSearch("cats", "**/*.md")

Safety First!

GenAIScript provides built-in Responsible AI system prompts and Azure Content Safety supports to validate content safety.

script({ ...,
    system: ["system.safety_harmful_content", ...],
    contentSafety: "azure" // use azure content safety
})

const safety = await host.contentSafety()
const res = await safety.detectPromptInjection(env.vars.input)

GitHub Models and GitHub Copilot

Run models through GitHub using GitHub Models or GitHub Copilot.

script({ ..., model: "github:gpt-4o" })

Google, Anthropic, Alibaba, ...

Run models from Google, Anthropic, Alibaba, and more. See Configuration.

script({ ..., model: "google:gemini-1.5-flash"})

Local Models

Run your scripts with Open Source models, like Phi-3, using Ollama, LocalAI…

script({ ..., model: "ollama:phi3" })

Code Interpreter

Let the LLM run code in a sandboxed execution environment.

script({ tools: ["python_code_interpreter"] })

Containers

Run code in Docker containers.

const c = await host.container({
    image: "python:alpine",
})
const res = await c.exec("python --version")

LLM Composition

Run LLMs to build your LLM prompts.

// summarize each files individually
for (const file of env.files) {
    const { text } = await runPrompt((_) => {
        _.def("FILE", file)
        _.$`Summarize the FILE.`
    })
    // use result in main prompt
    def("SUMMARY", text)
}
// use summary
$`Summarize all the summaries.`

Prompty

Run or convert Prompty files using GenAIScript.

---
name: poem
---

system:
Write a short poem about
user:
{{something}}.

importTemplate("poem.prompty", { something: "code " })

Automate with CLI

Automate using the CLI, integrate reports in your CI/CD pipeline.

npx genaiscript run tlaplus-linter "*.tla"

Pull Request Reviews

Integrate into your Pull Requests checks through comments, reviews or description updates. Supports GitHub Actions and Azure DevOps pipelines.

npx genaiscript ... --pull-request-reviews

Tests and Evals

Build reliable prompts using tests and evals powered by promptfoo.

script({ ..., tests: {
  files: "penguins.csv",
  rubric: "is a data analysis report",
  facts: "The data refers about penguin population in Antartica.",
}})

Visual Studio Test Explorer opened with a few genaiscript tests.

Case Studies

Tales from the real world using GenAIScript.

Bicep Best Practices Learn how to apply best practices to Azure Bicep files for more efficient and maintainable infrastructure as code.

SEO Front Matter Learn how to automate the creation of SEO-optimized front matter for your markdown documents with GenAIScript.

Documentation Translations Explore the challenges and solutions for localizing MakeCode documentation with custom macros while maintaining rich rendering in multiple languages.

Blocks Localization Learn how to localize MakeCode programming blocks while preserving block properties and variable names for international audiences.

Release Notes Generate comprehensive release notes combining commit history and code diffs

TLA+ AI Linter Explore how the TLA+ AI Linter leverages GenAI scripts and LLMs to enhance TLA+ specifications with automated linting and consistent comment verification.

Image Alt Text Learn how to automatically generate descriptive alt text for images using OpenAI Vision model to enhance accessibility and SEO.

Samples

Fully fledged scripts ready to use.

Diagram Class diagram generator

Lint An Easy Universal Linter

Pull Request Descriptor Generate a pull request description from the git diff

Image Alt Textify Generate alt text for images in markdown files

Pull Request Reviewer Review the current files or changes

Git Commit Message Generate a commit message for all staged changes

Search and transform Search for a pattern in files and apply an LLM transformation to the match

Commenter Adds comments to your code

GitHub Action Investigator Investigate GitHub Actions failures

Spell Checker Spell check a document

Guides

A cookbook full of recipes to make you a genius scripter.

Prompt As Code Tutorial on using GenAIScript runtime and syntax to assemble prompts

Sharing scripts Learn how to share GenAIScript scripts across projects using Git repositories, submodules, and GitHub Gists.

Ask My PDF Quick-start guide to using GenAIScript for summarizing and critiquing PDF documents with AI assistance.

Agentic tools Using agentic tools in your script

Ask My Image Learn how to apply GenAIScript to images for data extraction and analysis using AI models.

Detection of Outdated Descriptions Automate the detection of outdated descriptions in markdown documentation to maintain accuracy and consistency.

Present My Code Step-by-step instructions on presenting code effectively using GenAIScript and creating engaging slides.

Search and Fetch Learn how to leverage web search and fetching pages in GenAIScript

Tool Agent Learn how to define a built-in agent using functions for decision-making and reasoning in arithmetic operations.

Summarize Many Documents Learn how to run a GenAIScript over many documents

Containerized Tools Learn how to create and use containerized tools with executable dependencies in a secure environment using GCC as an example.

Generated Knowledge Explore the technique of generated knowledge in AI prompting to enhance accuracy in answering questions.

Phi-3 Mini with Ollama Learn how to integrate Phi-3 Mini, a powerful 3.8B parameter model by Microsoft, with Ollama for local execution of state-of-the-art AI models.

Business card scanner Using OpenAI Vision to scan business cards.

Automated Git Commit Messages Streamline your Git workflow with an automation script for generating commit messages

Issue Reviewer Learn how to automate reviewing issues with a script.

Llama Guard your files Automate the process of checking your files for harmful content using Llama-guard3.

LLM Agents Learn how to use the inline prompts to create a LLM agent.

Pull Request Reviewer Learn how to automate pull request reviews with a GenAIScript that provides feedback and code analysis in GitHub Actions.

Search And Transform Learn how to search and transform data in your data sources.

Transformer.js Implement summarization with Transformers.js and leverage local hardware acceleration

Using Secrets Utilize secrets to augment documents with TypeScript and REST APIs

Images in Azure Blob Storage Leverage Azure SDK to handle image files in Blob Storage within prompts

LLM as a tool Create tools and inline prompts using LLM models for executing various tasks

PDF Vision

Zod Schema Learn how to define and convert TypeScript-first Zod schemas to JSON schema

Agents

Builtin Agents

agent docs query the documentation

agent fs query files to accomplish tasks

agent git query a repository using Git to accomplish tasks. Provide all the context information available to execute git queries.

agent github query GitHub to accomplish tasks

agent interpreter run code interpreters for Python, Math. Use this agent to ground computation questions.

agent planner generates a plan to solve a task

agent user_input ask user for input to confirm, select or answer the question in the query. The message should be very clear and provide all the context.

agent web-search search the web to accomplish tasks.

LLM friendly docs

If you are an LLM crawler, fetch https://microsoft.github.io/genaiscript/.well-known/llms.txt for an documentation map or add the .md suffix to any documentation URLs to get a raw markdown content.

For example, https://microsoft.github.io/genaiscript/guides/prompt-as-code.md (note the .md extension)