Aspire

GitHubOfficialFirst committed by ChrisMcKee1Distributed by GitHub

Skill
Tool integration
Software development
MIT
Medium risk

From the author

Aspire skill covering the Aspire CLI, AppHost orchestration, service discovery, integrations, MCP server, VS Code extension, Dev Containers, GitHub Codespaces, templates, dashboard, and deployment. Use when the user asks to create, run, debug, configure, deploy, or troubleshoot an Aspire distributed application.

— the description by ChrisMcKee1

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Aspire is a code-first, polyglot orchestration framework designed to simplify the development, debugging, and deployment of distributed applications. It uses an AppHost project to manage the lifecycle of containers, executables, and cloud resources, providing a unified developer experience across various languages including C#, Python, Go, and JavaScript. The framework includes a local Developer Control Plane (DCP) for orchestration, a real-time dashboard for observability, and built-in support for service discovery and infrastructure integrations.

What it does

Orchestrates multi-service applications via a central AppHost project.
Provides a local runtime engine (DCP) for managing resource lifecycles.
Automates service discovery and configuration through environment variable injection.
Offers a real-time dashboard for monitoring logs, traces, and metrics.
Supports polyglot workloads including .NET, Python, Go, and Node.js.
Generates deployment manifests for cloud environments like Kubernetes and Azure.

When to use it

When building a distributed system that requires local orchestration of multiple services.
When you need to manage dependencies between containers, databases, and APIs.
When you want to simplify service discovery and configuration in a polyglot environment.
When you need to transition from local development to cloud deployment using standardized manifests.
When you require integrated observability and health checks during the development loop.

Advantages

Unified developer experience for polyglot distributed systems.
Code-first approach allows for programmatic infrastructure definition.
Automatic service discovery reduces manual configuration overhead.
Integrated dashboard provides immediate visibility into system health and logs.
Supports standard container runtimes and cloud-native deployment targets.

Usage examples

“Create a new Aspire project with a starter template.”: The agent executes 'aspire new aspire-starter' to generate a project structure containing an AppHost, service defaults, and sample services.
“How do I add a Redis cache to my existing Aspire AppHost?”: The agent guides you to run 'aspire add redis' and shows how to wire the resource in your AppHost using '.WithReference(redis)'.
“Run my distributed application locally.”: The agent triggers 'aspire run', which builds the AppHost, starts the DCP engine, manages resource dependencies, and opens the Aspire dashboard.
“How can I deploy my Aspire application to Kubernetes?”: The agent explains the use of 'aspire publish' to generate the necessary deployment manifests for your target environment.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/github/aspire/download
Unzip it into the cross-client skills folder of your project:
```
mkdir -p .agents/skills && unzip aspire.zip -d .agents/skills
```

Documentation by ChrisMcKee1

Aspire — Polyglot Distributed-App Orchestration

Aspire is a code-first, polyglot toolchain for building observable, production-ready distributed applications. It orchestrates containers, executables, and cloud resources from a single AppHost project — regardless of whether the workloads are C#, Python, JavaScript/TypeScript, Go, Java, Rust, Bun, Deno, or PowerShell.

Mental model: The AppHost is a conductor — it doesn't play the instruments, it tells every service when to start, how to find each other, and watches for problems.

Detailed reference material lives in the references/ folder — load on demand.

References

Reference	When to load
CLI Reference	Command flags, options, or detailed usage
MCP Server	Setting up MCP for AI assistants, available tools
Integrations Catalog	Discovering integrations via MCP tools, wiring patterns
Polyglot APIs	Method signatures, chaining options, language-specific patterns
Architecture	DCP internals, resource model, service discovery, networking, telemetry
Dashboard	Dashboard features, standalone mode, GenAI Visualizer
Deployment	Docker, Kubernetes, Azure Container Apps, App Service
Testing	Integration tests against the AppHost
Troubleshooting	Diagnostic codes, common errors, and fixes

1. Researching Aspire Documentation

The Aspire team ships an MCP server that provides documentation tools directly inside your AI assistant. See MCP Server for setup details.

Aspire CLI 13.2+ (recommended — has built-in docs search)

If running Aspire CLI 13.2 or later (aspire --version), the MCP server includes docs search tools:

Tool	Description
`list_docs`	Lists all available documentation from aspire.dev
`search_docs`	Performs weighted lexical search across indexed documentation
`get_doc`	Retrieves a specific document by its slug

These tools were added in PR #14028. To update: aspire update --self --channel daily.

For more on this approach, see David Pine's post: https://davidpine.dev/posts/aspire-docs-mcp-tools/

Aspire CLI 13.1 (integration tools only)

On 13.1, the MCP server provides integration lookup but not docs search:

Tool	Description
`list_integrations`	Lists available Aspire hosting integrations
`get_integration_docs`	Gets documentation for a specific integration package

For general docs queries on 13.1, use Context7 as your primary source (see below).

Fallback: Context7

Use Context7 (mcp_context7) when the Aspire MCP docs tools are unavailable (13.1) or the MCP server isn't running:

Step 1 — Resolve the library ID (one-time per session):

Call mcp_context7_resolve-library-id with libraryName: ".NET Aspire".

Rank	Library ID	Use when
1	`/microsoft/aspire.dev`	Primary source. Guides, integrations, CLI reference, deployment.
2	`/dotnet/aspire`	API internals, source-level implementation details.
3	`/communitytoolkit/aspire`	Non-Microsoft polyglot integrations (Go, Java, Node.js, Ollama).

Step 2 — Query docs:

libraryId: "/microsoft/aspire.dev", query: "Python integration AddPythonApp service discovery"
libraryId: "/communitytoolkit/aspire", query: "Golang Java Node.js community integrations"

Fallback: GitHub search (when Context7 is also unavailable)

Search the official docs repo on GitHub:

Docs repo: microsoft/aspire.dev — path: src/frontend/src/content/docs/
Source repo: dotnet/aspire
Samples repo: dotnet/aspire-samples
Community integrations: CommunityToolkit/Aspire

2. Prerequisites & Install

Requirement	Details
.NET SDK	10.0+ (required even for non-.NET workloads — the AppHost is .NET)
Container runtime	Docker Desktop, Podman, or Rancher Desktop
IDE (optional)	VS Code + C# Dev Kit, Visual Studio 2022, JetBrains Rider

# Linux / macOS
curl -sSL https://aspire.dev/install.sh | bash

# Windows PowerShell
irm https://aspire.dev/install.ps1 | iex

# Verify
aspire --version

# Install templates
dotnet new install Aspire.ProjectTemplates

3. Project Templates

Template	Command	Description
aspire-starter	`aspire new aspire-starter`	ASP.NET Core/Blazor starter + AppHost + tests
aspire-ts-cs-starter	`aspire new aspire-ts-cs-starter`	ASP.NET Core/React starter + AppHost
aspire-py-starter	`aspire new aspire-py-starter`	FastAPI/React starter + AppHost
aspire-apphost-singlefile	`aspire new aspire-apphost-singlefile`	Empty single-file AppHost

4. AppHost Quick Start (Polyglot)

The AppHost orchestrates all services. Non-.NET workloads run as containers or executables.

var builder = DistributedApplication.CreateBuilder(args);

// Infrastructure
var redis = builder.AddRedis("cache");
var postgres = builder.AddPostgres("pg").AddDatabase("catalog");

// .NET API
var api = builder.AddProject<Projects.CatalogApi>("api")
    .WithReference(postgres).WithReference(redis);

// Python ML service
var ml = builder.AddPythonApp("ml-service", "../ml-service", "main.py")
    .WithHttpEndpoint(targetPort: 8000).WithReference(redis);

// React frontend (Vite)
var web = builder.AddViteApp("web", "../frontend")
    .WithHttpEndpoint(targetPort: 5173).WithReference(api);

// Go worker
var worker = builder.AddGolangApp("worker", "../go-worker")
    .WithReference(redis);

builder.Build().Run();

For complete API signatures, see Polyglot APIs.

5. Core Concepts (Summary)

Concept	Key point
Run vs Publish	`aspire run` = local dev (DCP engine). `aspire publish` = generate deployment manifests.
Service discovery	Automatic via env vars: `ConnectionStrings__<name>`, `services__<name>__http__0`
Resource lifecycle	DAG ordering — dependencies start first. `.WaitFor()` gates on health checks.
Resource types	`ProjectResource`, `ContainerResource`, `ExecutableResource`, `ParameterResource`
Integrations	144+ across 13 categories. Hosting package (AppHost) + Client package (service).
Dashboard	Real-time logs, traces, metrics, GenAI visualizer. Runs automatically with `aspire run`.
MCP Server	AI assistants can query running apps and search docs via CLI (STDIO).
Testing	`Aspire.Hosting.Testing` — spin up full AppHost in xUnit/MSTest/NUnit.
Deployment	Docker, Kubernetes, Azure Container Apps, Azure App Service.

6. CLI Quick Reference

Valid commands in Aspire CLI 13.1:

Command	Description	Status
`aspire new <template>`	Create from template	Stable
`aspire init`	Initialize in existing project	Stable
`aspire run`	Start all resources locally	Stable
`aspire add <integration>`	Add an integration	Stable
`aspire publish`	Generate deployment manifests	Preview
`aspire config`	Manage configuration settings	Stable
`aspire cache`	Manage disk cache	Stable
`aspire deploy`	Deploy to defined targets	Preview
`aspire do <step>`	Execute a pipeline step	Preview
`aspire update`	Update integrations (or `--self` for CLI)	Preview
`aspire mcp init`	Configure MCP for AI assistants	Stable
`aspire mcp start`	Start the MCP server	Stable

Full command reference with flags: CLI Reference.

7. Common Patterns

Adding a new service

Create your service directory (any language)
Add to AppHost: Add*App() or AddProject<T>()
Wire dependencies: .WithReference()
Gate on health: .WaitFor() if needed
Run: aspire run

Migrating from Docker Compose

aspire new aspire-apphost-singlefile (empty AppHost)
Replace each docker-compose service with an Aspire resource
depends_on → .WithReference() + .WaitFor()
ports → .WithHttpEndpoint()
environment → .WithEnvironment() or .WithReference()

8. Key URLs

Resource	URL
Documentation	https://aspire.dev
Runtime repo	https://github.com/dotnet/aspire
Docs repo	https://github.com/microsoft/aspire.dev
Samples	https://github.com/dotnet/aspire-samples
Community Toolkit	https://github.com/CommunityToolkit/Aspire
Dashboard image	`mcr.microsoft.com/dotnet/aspire-dashboard`
Discord	https://aka.ms/aspire/discord
Reddit	https://www.reddit.com/r/aspiredotdev/

Files

ATTRIBUTION.mdAdded by AutoGineer851 B
LICENSELicence file added by AutoGineer1.0 KiB
SKILL.md9.1 KiB
references/architecture.md10.0 KiB
references/cli-reference.md8.5 KiB
references/dashboard.md6.3 KiB
references/deployment.md6.2 KiB
references/integrations-catalog.md5.0 KiB
references/mcp-server.md8.3 KiB
references/polyglot-apis.md8.8 KiB
references/testing.md7.4 KiB
references/troubleshooting.md10.8 KiB

references/cli-reference.md

CLI Reference — Complete Command Reference

The Aspire CLI (aspire) is the primary interface for creating, running, and publishing distributed applications. It is cross-platform and installed standalone (not coupled to the .NET CLI, though dotnet commands also work).

Tested against: Aspire CLI 13.1.0

Installation

# Linux / macOS
curl -sSL https://aspire.dev/install.sh | bash

# Windows PowerShell
irm https://aspire.dev/install.ps1 | iex

# Verify
aspire --version

# Update the CLI itself
aspire update --self

Global Options

All commands support these options:

Option	Description
`-d, --debug`	Enable debug logging to the console
`--non-interactive`	Disable all interactive prompts and spinners
`--wait-for-debugger`	Wait for a debugger to attach before executing
`-?, -h, --help`	Show help and usage information
`--version`	Show version information

Command Reference

`aspire new`

Create a new project from a template.

aspire new [<template>] [options]

# Options:
#   -n, --name <name>        Project name
#   -o, --output <dir>       Output directory
#   -s, --source <source>    NuGet source for templates
#   -v, --version <version>  Version of templates to use
#   --channel <channel>      Channel (stable, daily)

# Examples:
aspire new aspire-starter
aspire new aspire-starter -n MyApp -o ./my-app
aspire new aspire-ts-cs-starter
aspire new aspire-py-starter
aspire new aspire-apphost-singlefile

Available templates:

aspire-starter — ASP.NET Core/Blazor starter + AppHost + tests
aspire-ts-cs-starter — ASP.NET Core/React + AppHost
aspire-py-starter — FastAPI/React + AppHost
aspire-apphost-singlefile — Empty single-file AppHost

`aspire init`

Initialize Aspire in an existing project or solution.

aspire init [options]

# Options:
#   -s, --source <source>    NuGet source for templates
#   -v, --version <version>  Version of templates to use
#   --channel <channel>      Channel (stable, daily)

# Example:
cd my-existing-solution
aspire init

Adds AppHost and ServiceDefaults projects to an existing solution. Interactive prompts guide you through selecting which projects to orchestrate.

`aspire run`

Start all resources locally using the DCP (Developer Control Plane).

aspire run [options] [-- <additional arguments>]

# Options:
#   --project <path>       Path to AppHost project file

# Examples:
aspire run
aspire run --project ./src/MyApp.AppHost

Behavior:

Builds the AppHost project
Starts the DCP engine
Creates resources in dependency order (DAG)
Waits for health checks on gated resources
Opens the dashboard in the default browser
Streams logs to the terminal

Press Ctrl+C to gracefully stop all resources.

`aspire add`

Add a hosting integration to the AppHost.

aspire add [<integration>] [options]

# Options:
#   --project <path>         Target project file
#   -v, --version <version>  Version of integration to add
#   -s, --source <source>    NuGet source for integration

# Examples:
aspire add redis
aspire add postgresql
aspire add mongodb

`aspire publish` (Preview)

Generate deployment manifests from the AppHost resource model.

aspire publish [options] [-- <additional arguments>]

# Options:
#   --project <path>                   Path to AppHost project file
#   -o, --output-path <path>           Output directory (default: ./aspire-output)
#   --log-level <level>                Log level (trace, debug, information, warning, error, critical)
#   -e, --environment <env>            Environment (default: Production)
#   --include-exception-details        Include stack traces in pipeline logs

# Examples:
aspire publish
aspire publish --output-path ./deploy
aspire publish -e Staging

`aspire config`

Manage Aspire configuration settings.

aspire config <subcommand>

# Subcommands:
#   get <key>              Get a configuration value
#   set <key> <value>      Set a configuration value
#   list                   List all configuration values
#   delete <key>           Delete a configuration value

# Examples:
aspire config list
aspire config set telemetry.enabled false
aspire config get telemetry.enabled
aspire config delete telemetry.enabled

`aspire cache`

Manage disk cache for CLI operations.

aspire cache <subcommand>

# Subcommands:
#   clear                  Clear all cache entries

# Example:
aspire cache clear

`aspire deploy` (Preview)

Deploy the contents of an Aspire apphost to its defined deployment targets.

aspire deploy [options] [-- <additional arguments>]

# Options:
#   --project <path>                   Path to AppHost project file
#   -o, --output-path <path>           Output path for deployment artifacts
#   --log-level <level>                Log level (trace, debug, information, warning, error, critical)
#   -e, --environment <env>            Environment (default: Production)
#   --include-exception-details        Include stack traces in pipeline logs
#   --clear-cache                      Clear deployment cache for current environment

# Example:
aspire deploy --project ./src/MyApp.AppHost

`aspire do` (Preview)

Execute a specific pipeline step and its dependencies.

aspire do <step> [options] [-- <additional arguments>]

# Options:
#   --project <path>                   Path to AppHost project file
#   -o, --output-path <path>           Output path for artifacts
#   --log-level <level>                Log level (trace, debug, information, warning, error, critical)
#   -e, --environment <env>            Environment (default: Production)
#   --include-exception-details        Include stack traces in pipeline logs

# Example:
aspire do build-images --project ./src/MyApp.AppHost

`aspire update` (Preview)

Update integrations in the Aspire project, or update the CLI itself.

aspire update [options]

# Options:
#   --project <path>       Path to AppHost project file
#   --self                 Update the Aspire CLI itself to the latest version
#   --channel <channel>    Channel to update to (stable, daily)

# Examples:
aspire update                          # Update project integrations
aspire update --self                   # Update the CLI itself
aspire update --self --channel daily   # Update CLI to daily build

`aspire mcp`

Manage the MCP (Model Context Protocol) server.

aspire mcp <subcommand>

# Subcommands:
#   init    Initialize MCP server configuration for detected agent environments
#   start   Start the MCP server

`aspire mcp init`

aspire mcp init

# Interactive — detects your AI environment and creates config files.
# Supported environments:
# - VS Code (GitHub Copilot)
# - Copilot CLI
# - Claude Code
# - OpenCode

Generates the appropriate configuration file for your detected AI tool. See MCP Server for details.

`aspire mcp start`

aspire mcp start

# Starts the MCP server using STDIO transport.
# This is typically invoked by your AI tool, not run manually.

Commands That Do NOT Exist

The following commands are not valid in Aspire CLI 13.1. Use alternatives:

Invalid Command	Alternative
`aspire build`	Use `dotnet build ./AppHost`
`aspire test`	Use `dotnet test ./Tests`
`aspire dev`	Use `aspire run` (includes file watching)
`aspire list`	Use `aspire new --help` for templates, `aspire add` for integrations

.NET CLI equivalents

The dotnet CLI can perform some Aspire tasks:

Aspire CLI	.NET CLI Equivalent
`aspire new aspire-starter`	`dotnet new aspire-starter`
`aspire run`	`dotnet run --project ./AppHost`
N/A	`dotnet build ./AppHost`
N/A	`dotnet test ./Tests`

The Aspire CLI adds value with publish, deploy, add, mcp, config, cache, do, and update — commands that have no direct dotnet equivalent.

Requirements and compatibility

Written for: GitHub Copilot

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an MCP server, Needs network access

Security

What our scanner noticed· Medium risk

Instructions that use the network
Downloads piped into a shell

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

First committed by

ChrisMcKee1

Publisher

GitHub (Official)

Distributed by

GitHub

Source

github/awesome-copilot · skills/aspire · commit 797337f

Licence

MIT License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

Contributors

ChrisMcKee1

AutoGineer is not affiliated with or endorsed by ChrisMcKee1 or GitHub.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download aspire.zip