> ## Documentation Index
> Fetch the complete documentation index at: https://tawkitai-alem-extract-zod-from-core.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Overview

> Server adapter package overview

# AGUI.Server

`AGUI.Server` is the .NET server-side adapter for AG-UI. It converts a
`Microsoft.Extensions.AI.IChatClient` stream into AG-UI protocol events, so you
can expose any chat client as an AG-UI endpoint that accepts `RunAgentInput` and
streams AG-UI events to a frontend UI.

```bash theme={null}
dotnet add package AGUI.Server
```

## The core idea

You do not learn a new agent programming model. You host an `IChatClient`.

The package adapts AG-UI request bodies into `Microsoft.Extensions.AI`
messages and options, calls your chat client, then converts the streamed
`ChatResponseUpdate` values back into AG-UI protocol events.

## What it depends on

`AGUI.Server` is intentionally small:

* [AG-UI protocol types](/sdk/dotnet/abstractions/events) from
  `AGUI.Abstractions`
* `Microsoft.Extensions.AI.Abstractions`

It is framework-agnostic: it does not depend on ASP.NET Core or any web
framework. You host the adapter inside the web framework of your choice (the
samples and docs use ASP.NET Core). It also does not depend on the .NET AG-UI
client package. The server and client packages share protocol types, but remain
independent.

<Note>
  The server package targets `net10.0`, `net9.0`, and `net8.0`.
</Note>

## What the hosting layer handles

The hosting layer handles the protocol details for you:

* Converts `RunAgentInput.Messages` into `ChatMessage` values
* Translates `RunAgentInput.Resume` into MEAI approval and interrupt response
  content
* Installs client-declared tools on `ChatOptions`
* Stores the original input under
  `ChatOptions.AdditionalProperties[AGUIConstants.RunAgentInputKey]`
* Emits `RUN_STARTED` and terminal `RUN_FINISHED` outcomes
* Maps text, reasoning, tool calls, tool results, state, raw events, and
  interrupts to AG-UI events
* Streams the result as Server-Sent Events

## Verification and framework ownership

Server tests verify that `RunAgentInput` becomes `ChatMessage` and
`ChatOptions`, resume payloads become standard MEAI response content, lifecycle
events are emitted, and streamed `ChatResponseUpdate` values become the
expected text, reasoning, tool, state, raw, custom, and interrupt events. Raw
AG-UI events, including `RUN_ERROR`, pass through when supplied on
`ChatResponseUpdate.RawRepresentation`.

```bash theme={null}
cd sdks/dotnet
dotnet test tests/AGUI.Server.UnitTests/
dotnet test tests/AGUI.Hosting.AspNetCore.IntegrationTests/
```

The SDK owns the shared AG-UI and `Microsoft.Extensions.AI` bridge.
Framework-specific mappings belong to the consuming framework. For example,
Microsoft Agent Framework can use `AGUI.Server` for the common bridge, then map
its own workflow, step, and agent events with `AGUIStreamOptions` or raw AG-UI
events.

## Server and client together

Use `AGUI.Server` when you are building an AG-UI server. Use
[AGUI.Client](/sdk/dotnet/client/overview) when .NET code needs to consume an
AG-UI endpoint as an `IChatClient`.

<CardGroup cols={2}>
  <Card title="Endpoints" icon="server" href="/sdk/dotnet/hosting/endpoints" color="#3B82F6" iconType="solid">
    Build the canonical ASP.NET Core AG-UI endpoint
  </Card>

  <Card title="Extensibility" icon="layer-group" href="/sdk/dotnet/hosting/extensibility" color="#3B82F6" iconType="solid">
    Customize stream conversion with AGUIStreamOptions
  </Card>
</CardGroup>