Use AI models from GitHub Models in your workflows.

Create a workflow to use the AI inference action:

name: 'AI inference'
on: workflow_dispatch

jobs:
  inference:
    permissions:
      models: read
    runs-on: ubuntu-latest
    steps:
      - name: Test Local Action
        id: inference
        uses: actions/ai-inference@v1
        with:
          prompt: 'Hello!'

      - name: Print Output
        id: output
        run: echo "${{ steps.inference.outputs.response }}"

You can also provide a prompt file instead of an inline prompt. The action supports both plain text files and structured .prompt.yml files:

steps:
  - name: Run AI Inference with Text File
    id: inference
    uses: actions/ai-inference@v1
    with:
      prompt-file: './path/to/prompt.txt'

For more advanced use cases, you can use structured .prompt.yml files that support templating, custom models, and JSON schema responses:

steps:
  - name: Run AI Inference with Prompt YAML
    id: inference
    uses: actions/ai-inference@v1
    with:
      prompt-file: './.github/prompts/sample.prompt.yml'
      input: |
        var1: hello
        var2: ${{ steps.some-step.outputs.output }}
        var3: |
          Lorem Ipsum
          Hello World

messages:
  - role: system
    content: Be as concise as possible
  - role: user
    content: 'Compare {{a}} and {{b}}, please'
model: openai/gpt-4o

messages:
  - role: system
    content:
      You are a helpful assistant that describes animals using JSON format
  - role: user
    content: |-
      Describe a {{animal}}
      Use JSON format as specified in the response schema
model: openai/gpt-4o
responseFormat: json_schema
jsonSchema: |-
  {
    "name": "describe_animal",
    "strict": true,
    "schema": {
      "type": "object",
      "properties": {
        "name": {
          "type": "string",
          "description": "The name of the animal"
        },
        "habitat": {
          "type": "string",
          "description": "The habitat the animal lives in"
        }
      },
      "additionalProperties": false,
      "required": [
        "name",
        "habitat"
      ]
    }
  }

Variables in prompt.yml files are templated using {{variable}} format and are supplied via the input parameter in YAML format.

In addition to the regular prompt, you can provide a system prompt file instead of an inline system prompt:

steps:
  - name: Run AI Inference with System Prompt File
    id: inference
    uses: actions/ai-inference@v1
    with:
      prompt: 'Hello!'
      system-prompt-file: './path/to/system-prompt.txt'

This can be useful when model response exceeds actions output limit

steps:
  - name: Test Local Action
    id: inference
    uses: actions/ai-inference@v1
    with:
      prompt: 'Hello!'

  - name: Use Response File
    run: |
      echo "Response saved to: ${{ steps.inference.outputs.response-file }}"
      cat "${{ steps.inference.outputs.response-file }}"

This action now supports read-only integration with the GitHub-hosted Model Context Protocol (MCP) server, which provides access to GitHub tools like repository management, issue tracking, and pull request operations.

steps:
  - name: AI Inference with GitHub Tools
    id: inference
    uses: actions/ai-inference@v1.2
    with:
      prompt: 'List my open pull requests and create a summary'
      enable-github-mcp: true
      token: ${{ secrets.USER_PAT }}

When MCP is enabled, the AI model will have access to GitHub tools and can perform actions like searching issues and PRs.

Note: For now, MCP integration cannot be used with the built-in token. You must pass a GitHub PAT into token: instead.

Various inputs are defined in action.yml to let you configure the action:

The AI inference action provides the following outputs:

In order to run inference with GitHub Models, the GitHub AI inference action requires models permissions.

permissions:
  contents: read
  models: read

This project includes a helper script, script/release designed to streamline the process of tagging and pushing new releases for GitHub Actions. For more information, see Versioning in the GitHub Actions toolkit.

GitHub Actions allows users to select a specific version of the action to use, based on release tags. This script simplifies this process by performing the following steps:

1. Retrieving the latest release tag: The script starts by fetching the most recent SemVer release tag of the current branch, by looking at the local data available in your repository.
2. Prompting for a new release tag: The user is then prompted to enter a new release tag. To assist with this, the script displays the tag retrieved in the previous step, and validates the format of the inputted tag (vX.X.X). The user is also reminded to update the version field in package.json.
3. Tagging the new release: The script then tags a new release and syncs the separate major tag (e.g. v1, v2) with the new release tag (e.g. v1.0.0, v2.1.2). When the user is creating a new major release, the script auto-detects this and creates a releases/v# branch for the previous major version.
4. Pushing changes to remote: Finally, the script pushes the necessary commits, tags and branches to the remote repository. From here, you will need to create a new release in GitHub so users can easily reference the new tags in their workflows.

This project is licensed under the terms of the MIT open source license. Please refer to MIT for the full terms.

Contributions are welcome! See the Contributor's Guide.