Erste Schritte mit AG-UI

In diesem Lernprogramm wird das Erstellen von Server- und Clientanwendungen mithilfe des AG-UI-Protokolls mit .NET oder Python und Agent Framework veranschaulicht. Sie erfahren, wie Sie einen AG-UI-Server erstellen, der einen KI-Agent und einen Client hostt, der eine Verbindung mit diesem für interaktive Unterhaltungen herstellt.

Was Sie erstellen werden

Am Ende dieses Lernprogramms haben Sie Folgendes:

Ein AG-UI Server, auf den ein KI-Agent gehostet wird, auf den über HTTP zugegriffen werden kann
Eine Clientanwendung, die eine Verbindung mit dem Server herstellt und Antworten streamt
Grundlegendes zur Funktionsweise des AG-UI-Protokolls mit Agent Framework

Voraussetzungen

Bevor Sie beginnen, stellen Sie folgendes sicher:

.NET 8.0 oder höher
Azure OpenAI-Dienstendpunkt und -Bereitstellung konfiguriert
Azure CLI installiert und authentifiziert
Der Benutzer hat die Cognitive Services OpenAI Contributor Rolle für die Azure OpenAI-Ressource

Hinweis

In diesen Beispielen werden Azure OpenAI-Modelle verwendet. Weitere Informationen finden Sie unter Bereitstellen von Azure OpenAI-Modellen mit Azure AI Foundry.

Hinweis

In diesen Beispielen wird DefaultAzureCredential zur Authentifizierung verwendet. Stellen Sie sicher, dass Sie bei Azure authentifiziert sind (z. B. über az login). Weitere Informationen finden Sie in der Azure Identity-Dokumentation.

Warnung

Das AG-UI Protokoll befindet sich noch in der Entwicklung und kann geändert werden. Wir werden diese Beispiele aktualisieren, während sich das Protokoll weiterentwickelt.

Schritt 1: Erstellen eines AG-UI Servers

Der AG-UI-Server hostet Ihren KI-Agent und macht ihn über HTTP-Endpunkte mit ASP.NET Core verfügbar.

Hinweis

Für das Serverprojekt ist das Microsoft.NET.Sdk.Web SDK erforderlich. Wenn Sie ein neues Projekt von Grund auf neu erstellen, verwenden Sie dotnet new web oder stellen Sie sicher, dass Ihre .csproj-Datei <Project Sdk="Microsoft.NET.Sdk.Web"> anstelle von Microsoft.NET.Sdk verwendet.

Erforderliche Pakete installieren

Installieren Sie die erforderlichen Pakete für den Server:

dotnet add package Microsoft.Agents.AI.Hosting.AGUI.AspNetCore --prerelease
dotnet add package Azure.AI.OpenAI --prerelease
dotnet add package Azure.Identity
dotnet add package Microsoft.Extensions.AI.OpenAI --prerelease

Hinweis

Das Microsoft.Extensions.AI.OpenAI Paket ist für die AsIChatClient() Erweiterungsmethode erforderlich, die OpenAIs ChatClient in die Schnittstelle konvertiert, die vom Agent Framework erwartet wird.

Servercode

Erstellen einer Datei mit dem Namen Program.cs:

// Copyright (c) Microsoft. All rights reserved.

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI.Hosting.AGUI.AspNetCore;
using Microsoft.Extensions.AI;
using OpenAI.Chat;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
builder.Services.AddHttpClient().AddLogging();
builder.Services.AddAGUI();

WebApplication app = builder.Build();

string endpoint = builder.Configuration["AZURE_OPENAI_ENDPOINT"]
    ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
string deploymentName = builder.Configuration["AZURE_OPENAI_DEPLOYMENT_NAME"]
    ?? throw new InvalidOperationException("AZURE_OPENAI_DEPLOYMENT_NAME is not set.");

// Create the AI agent
ChatClient chatClient = new AzureOpenAIClient(
        new Uri(endpoint),
        new DefaultAzureCredential())
    .GetChatClient(deploymentName);

AIAgent agent = chatClient.AsIChatClient().AsAIAgent(
    name: "AGUIAssistant",
    instructions: "You are a helpful assistant.");

// Map the AG-UI agent endpoint
app.MapAGUI("/", agent);

await app.RunAsync();

Wichtige Konzepte

AddAGUI: Registriert AG-UI Dienste mit dem Container zum Einfügen von Abhängigkeiten
MapAGUI: Erweiterungsmethode, die den AG-UI-Endpunkt mit automatischer Anforderungs-/Antwortbehandlung und SSE-Streaming registriert
ChatClient und AsIChatClient(): AzureOpenAIClient.GetChatClient() gibt den Typ von ChatClient OpenAI zurück. Die AsIChatClient() Erweiterungsmethode (von Microsoft.Extensions.AI.OpenAI) konvertiert sie in die vom Agent Framework benötigte Schnittstelle.
AsAIAgent: Erstellt einen Agent Framework-Agent aus einem IChatClient
ASP.NET Core-Integration: Verwendet die native asynchrone Unterstützung von ASP.NET Core für Streamingantworten.
Anweisungen: Der Agent wird mit Standardanweisungen erstellt, die von Clientnachrichten überschrieben werden können.
Konfiguration: AzureOpenAIClient mit DefaultAzureCredential bietet sichere Authentifizierung

Konfigurieren und Ausführen des Servers

Legen Sie die erforderlichen Umgebungsvariablen fest:

export AZURE_OPENAI_ENDPOINT="https://your-resource.openai.azure.com/"
export AZURE_OPENAI_DEPLOYMENT_NAME="gpt-4o-mini"

Führen Sie den Server aus:

dotnet run --urls http://localhost:8888

Der Server beginnt auf http://localhost:8888 zu lauschen.

Hinweis

Lassen Sie diesen Server laufen, während Sie den Client in Schritt 2 einrichten und ausführen. Sowohl der Server als auch der Client müssen gleichzeitig ausgeführt werden, damit das gesamte System funktioniert.

Schritt 2: Erstellen eines AG-UI-Clients

Der AG-UI-Client verbindet sich mit dem Remoteserver und zeigt Streaming-Antworten an.

Von Bedeutung

Stellen Sie vor dem Ausführen des Clients sicher, dass der AG-UI Server aus Schritt 1 läuft. http://localhost:8888

Erforderliche Pakete installieren

Installieren Sie die AG-UI Clientbibliothek:

dotnet add package Microsoft.Agents.AI.AGUI --prerelease
dotnet add package Microsoft.Agents.AI --prerelease

Hinweis

Das Microsoft.Agents.AI Paket stellt die AsAIAgent() Erweiterungsmethode bereit.

Kundencode

Erstellen einer Datei mit dem Namen Program.cs:

// Copyright (c) Microsoft. All rights reserved.

using Microsoft.Agents.AI;
using Microsoft.Agents.AI.AGUI;
using Microsoft.Extensions.AI;

string serverUrl = Environment.GetEnvironmentVariable("AGUI_SERVER_URL") ?? "http://localhost:8888";

Console.WriteLine($"Connecting to AG-UI server at: {serverUrl}\n");

// Create the AG-UI client agent
using HttpClient httpClient = new()
{
    Timeout = TimeSpan.FromSeconds(60)
};

AGUIChatClient chatClient = new(httpClient, serverUrl);

AIAgent agent = chatClient.AsAIAgent(
    name: "agui-client",
    description: "AG-UI Client Agent");

AgentSession session = await agent.CreateSessionAsync();
List<ChatMessage> messages =
[
    new(ChatRole.System, "You are a helpful assistant.")
];

try
{
    while (true)
    {
        // Get user input
        Console.Write("\nUser (:q or quit to exit): ");
        string? message = Console.ReadLine();

        if (string.IsNullOrWhiteSpace(message))
        {
            Console.WriteLine("Request cannot be empty.");
            continue;
        }

        if (message is ":q" or "quit")
        {
            break;
        }

        messages.Add(new ChatMessage(ChatRole.User, message));

        // Stream the response
        bool isFirstUpdate = true;
        string? threadId = null;

        await foreach (AgentResponseUpdate update in agent.RunStreamingAsync(messages, session))
        {
            ChatResponseUpdate chatUpdate = update.AsChatResponseUpdate();

            // First update indicates run started
            if (isFirstUpdate)
            {
                threadId = chatUpdate.ConversationId;
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine($"\n[Run Started - Thread: {chatUpdate.ConversationId}, Run: {chatUpdate.ResponseId}]");
                Console.ResetColor();
                isFirstUpdate = false;
            }

            // Display streaming text content
            foreach (AIContent content in update.Contents)
            {
                if (content is TextContent textContent)
                {
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Console.Write(textContent.Text);
                    Console.ResetColor();
                }
                else if (content is ErrorContent errorContent)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"\n[Error: {errorContent.Message}]");
                    Console.ResetColor();
                }
            }
        }

        Console.ForegroundColor = ConsoleColor.Green;
        Console.WriteLine($"\n[Run Finished - Thread: {threadId}]");
        Console.ResetColor();
    }
}
catch (Exception ex)
{
    Console.WriteLine($"\nAn error occurred: {ex.Message}");
}

Wichtige Konzepte

Server-Sent Events (SSE): Das Protokoll verwendet SSE für Streamingantworten.
AGUIChatClient: Clientklasse, die eine Verbindung mit AG-UI Servern herstellt und implementiert IChatClient
AsAIAgent: Erweiterungsmethode zum AGUIChatClient Erstellen eines Agents vom Client
RunStreamingAsync: Streamt Antworten als AgentResponseUpdate Objekte
AsChatResponseUpdate: Erweiterungsmethode für den Zugriff auf chatspezifische Eigenschaften wie ConversationId und ResponseId
Sitzungsverwaltung: Das AgentSession verwaltet den Sitzungskontext über Anforderungen hinweg.
Inhaltstypen: Antworten umfassen TextContent Nachrichten und ErrorContent Fehler

Konfigurieren und Ausführen des Clients

Optional eine benutzerdefinierte Server-URL festlegen:

export AGUI_SERVER_URL="http://localhost:8888"

Führen Sie den Client in einem separaten Terminal aus (stellen Sie sicher, dass der Server aus Schritt 1 ausgeführt wird):

dotnet run

Schritt 3: Testen des vollständigen Systems

Wenn sowohl der Server als auch der Client ausgeführt wird, können Sie jetzt das vollständige System testen.

Erwartete Ausgabe

$ dotnet run
Connecting to AG-UI server at: http://localhost:8888

User (:q or quit to exit): What is 2 + 2?

[Run Started - Thread: thread_abc123, Run: run_xyz789]
2 + 2 equals 4.
[Run Finished - Thread: thread_abc123]

User (:q or quit to exit): Tell me a fun fact about space

[Run Started - Thread: thread_abc123, Run: run_def456]
Here's a fun fact: A day on Venus is longer than its year! Venus takes
about 243 Earth days to rotate once on its axis, but only about 225 Earth
days to orbit the Sun.
[Run Finished - Thread: thread_abc123]

User (:q or quit to exit): :q

Farbkodierte Ausgabe

Der Client zeigt verschiedene Inhaltstypen mit unterschiedlichen Farben an:

Gelb: Gestartete Benachrichtigungen ausführen
Cyan: Agent-Textantworten (in Echtzeit gestreamt)
Grün: Ausführen von Abschlussbenachrichtigungen
Rot: Fehlermeldungen

Funktionsweise

Server-Side Ablauf

Client sendet HTTP POST-Anforderung mit Nachrichten
ASP.NET Core-Endpunkt empfängt die Anforderung über MapAGUI
Agent verarbeitet die Nachrichten mithilfe von Agent Framework
Antworten werden in AG-UI Ereignisse konvertiert.
Die Ereignisse werden als Server-Sent Events (SSE) gestreamt.
Die Verbindung schließt, wenn der Lauf abgeschlossen ist.

Client-seitiger Ablauf

AGUIChatClient sendet HTTP POST-Anforderung an den Serverendpunkt
Server antwortet mit SSE-Stream
Client analysiert eingehende Ereignisse in AgentResponseUpdate Objekte
Jedes Update wird basierend auf seinem Inhaltstyp angezeigt.
ConversationId wird zur Wahrung der Gesprächskontinuität erfasst.
Der Stream wird abgeschlossen, wenn der Lauf beendet ist.

Protokolldetails

Das AG-UI Protokoll verwendet:

HTTP POST zum Senden von Anforderungen
Server-Sent Events (SSE) für Streamingantworten
JSON für die Ereignis serialisierung
Thread-IDs (als ConversationId) zur Aufrechterhaltung des Konversationskontexts
Ausführungs-IDs (as ResponseId) zum Nachverfolgen einzelner Ausführungen

Nächste Schritte

Nachdem Sie nun die Grundlagen der AG-UI verstanden haben, können Sie:

Hinzufügen von Back-End-Tools: Erstellen von benutzerdefinierten Funktionstools für Ihre Domäne

Zusätzliche Ressourcen

Voraussetzungen

Bevor Sie beginnen, stellen Sie folgendes sicher:

Python 3.10 oder höher
Azure OpenAI-Dienstendpunkt und -Bereitstellung konfiguriert
Azure CLI installiert und authentifiziert
Der Benutzer hat die Cognitive Services OpenAI Contributor Rolle für die Azure OpenAI-Ressource

Hinweis

In diesen Beispielen werden Azure OpenAI-Modelle verwendet. Weitere Informationen finden Sie unter Bereitstellen von Azure OpenAI-Modellen mit Azure AI Foundry.

Hinweis

Warnung

Das AG-UI Protokoll befindet sich noch in der Entwicklung und kann geändert werden. Wir werden diese Beispiele aktualisieren, während sich das Protokoll weiterentwickelt.

Schritt 1: Erstellen eines AG-UI Servers

Der AG-UI-Server hostet Ihren KI-Agent und macht ihn über HTTP-Endpunkte mit FastAPI verfügbar.

Erforderliche Pakete installieren

Installieren Sie die erforderlichen Pakete für den Server:

pip install agent-framework-ag-ui --pre

Oder uv verwenden:

uv pip install agent-framework-ag-ui --prerelease=allow

Dadurch werden agent-framework-core, fastapi und uvicorn automatisch als Abhängigkeiten installiert.

Servercode

Erstellen einer Datei mit dem Namen server.py:

"""AG-UI server example."""

import os

from agent_framework import Agent
from agent_framework.azure import AzureOpenAIChatClient
from agent_framework_ag_ui import add_agent_framework_fastapi_endpoint
from azure.identity import AzureCliCredential
from fastapi import FastAPI

# Read required configuration
endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT")
deployment_name = os.environ.get("AZURE_OPENAI_DEPLOYMENT_NAME")

if not endpoint:
    raise ValueError("AZURE_OPENAI_ENDPOINT environment variable is required")
if not deployment_name:
    raise ValueError("AZURE_OPENAI_DEPLOYMENT_NAME environment variable is required")

chat_client = AzureOpenAIChatClient(
    credential=AzureCliCredential(),
    endpoint=endpoint,
    deployment_name=deployment_name,
)

# Create the AI agent
agent = Agent(
    name="AGUIAssistant",
    instructions="You are a helpful assistant.",
    chat_client=chat_client,
)

# Create FastAPI app
app = FastAPI(title="AG-UI Server")

# Register the AG-UI endpoint
add_agent_framework_fastapi_endpoint(app, agent, "/")

if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="127.0.0.1", port=8888)

Wichtige Konzepte

add_agent_framework_fastapi_endpoint: Registriert den AG-UI Endpunkt mit automatischer Anforderungs-/Antwortbehandlung und SSE-Streaming
Agent: Der Agent Framework-Agent, der eingehende Anforderungen verarbeitet
FastAPI-Integration: Verwendet die systemeigene asynchrone Unterstützung von FastAPI für Streamingantworten
Anweisungen: Der Agent wird mit Standardanweisungen erstellt, die von Clientnachrichten überschrieben werden können.
Konfiguration: AzureOpenAIChatClient liest aus Umgebungsvariablen oder akzeptiert Parameter direkt

Konfigurieren und Ausführen des Servers

Legen Sie die erforderlichen Umgebungsvariablen fest:

export AZURE_OPENAI_ENDPOINT="https://your-resource.openai.azure.com/"
export AZURE_OPENAI_DEPLOYMENT_NAME="gpt-4o-mini"

Führen Sie den Server aus:

python server.py

Oder verwenden Sie uvicorn direkt:

uvicorn server:app --host 127.0.0.1 --port 8888

Der Server beginnt auf http://127.0.0.1:8888 zu lauschen.

Schritt 2: Erstellen eines AG-UI-Clients

Der AG-UI-Client verbindet sich mit dem Remoteserver und zeigt Streaming-Antworten an.

Erforderliche Pakete installieren

Das AG-UI-Paket ist bereits installiert, einschließlich: AGUIChatClient

# Already installed with agent-framework-ag-ui
pip install agent-framework-ag-ui --pre

Kundencode

Erstellen einer Datei mit dem Namen client.py:

"""AG-UI client example."""

import asyncio
import os

from agent_framework import Agent
from agent_framework_ag_ui import AGUIChatClient


async def main():
    """Main client loop."""
    # Get server URL from environment or use default
    server_url = os.environ.get("AGUI_SERVER_URL", "http://127.0.0.1:8888/")
    print(f"Connecting to AG-UI server at: {server_url}\n")

    # Create AG-UI chat client
    chat_client = AGUIChatClient(server_url=server_url)

    # Create agent with the chat client
    agent = Agent(
        name="ClientAgent",
        chat_client=chat_client,
        instructions="You are a helpful assistant.",
    )

    # Get a thread for conversation continuity
    thread = agent.create_session()

    try:
        while True:
            # Get user input
            message = input("\nUser (:q or quit to exit): ")
            if not message.strip():
                print("Request cannot be empty.")
                continue

            if message.lower() in (":q", "quit"):
                break

            # Stream the agent response
            print("\nAssistant: ", end="", flush=True)
            async for update in agent.run(message, session=thread, stream=True):
                # Print text content as it streams
                if update.text:
                    print(f"\033[96m{update.text}\033[0m", end="", flush=True)

            print("\n")

    except KeyboardInterrupt:
        print("\n\nExiting...")
    except Exception as e:
        print(f"\n\033[91mAn error occurred: {e}\033[0m")


if __name__ == "__main__":
    asyncio.run(main())

Wichtige Konzepte

Server-Sent Events (SSE):Das Protokoll verwendet das SSE-Format (data: {json}\n\n)
Ereignistypen: Verschiedene Ereignisse stellen Metadaten und Inhalte bereit (UPPERCASE mit Unterstrichen):
- RUN_STARTED: Agent hat mit der Verarbeitung begonnen
- TEXT_MESSAGE_START: Beginn einer Textnachricht vom Agent
- TEXT_MESSAGE_CONTENT: Inkrementeller Text, der vom Agent gestreamt wurde (mit delta Feld)
- TEXT_MESSAGE_END: Ende einer Textnachricht
- RUN_FINISHED: Erfolgreicher Abschluss
- RUN_ERROR: Fehlerinformationen
Feldbenennung: Ereignisfelder verwenden camelCase (z. B. threadId, , runId) messageId
Threadverwaltung: Das threadId verwaltet den Gesprächskontext über Anfragen hinweg.
Client-Side Anweisungen: Vom Client gesendete Systemnachrichten

Konfigurieren und Ausführen des Clients

Optional eine benutzerdefinierte Server-URL festlegen:

export AGUI_SERVER_URL="http://127.0.0.1:8888/"

Führen Sie den Client aus (in einem separaten Terminal):

python client.py

Schritt 3: Testen des vollständigen Systems

Wenn sowohl der Server als auch der Client ausgeführt wird, können Sie jetzt das vollständige System testen.

Erwartete Ausgabe

$ python client.py
Connecting to AG-UI server at: http://127.0.0.1:8888/

User (:q or quit to exit): What is 2 + 2?

[Run Started - Thread: abc123, Run: xyz789]
2 + 2 equals 4.
[Run Finished - Thread: abc123, Run: xyz789]

User (:q or quit to exit): Tell me a fun fact about space

[Run Started - Thread: abc123, Run: def456]
Here's a fun fact: A day on Venus is longer than its year! Venus takes
about 243 Earth days to rotate once on its axis, but only about 225 Earth
days to orbit the Sun.
[Run Finished - Thread: abc123, Run: def456]

User (:q or quit to exit): :q

Farbkodierte Ausgabe

Der Client zeigt verschiedene Inhaltstypen mit unterschiedlichen Farben an:

Gelb: Gestartete Benachrichtigungen ausführen
Cyan: Agent-Textantworten (in Echtzeit gestreamt)
Grün: Ausführen von Abschlussbenachrichtigungen
Rot: Fehlermeldungen

Testen mit curl (optional)

Bevor Sie den Client ausführen, können Sie den Server manuell mit curl testen:

curl -N http://127.0.0.1:8888/ \
  -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" \
  -d '{
    "messages": [
      {"role": "user", "content": "What is 2 + 2?"}
    ]
  }'

Sie sollten das Streaming von Server-Sent-Events wieder sehen.

data: {"type":"RUN_STARTED","threadId":"...","runId":"..."}

data: {"type":"TEXT_MESSAGE_START","messageId":"...","role":"assistant"}

data: {"type":"TEXT_MESSAGE_CONTENT","messageId":"...","delta":"The"}

data: {"type":"TEXT_MESSAGE_CONTENT","messageId":"...","delta":" answer"}

...

data: {"type":"TEXT_MESSAGE_END","messageId":"..."}

data: {"type":"RUN_FINISHED","threadId":"...","runId":"..."}

Funktionsweise

Server-Side Ablauf

Client sendet HTTP POST-Anforderung mit Nachrichten
Der FastAPI-Endpunkt empfängt die Anforderung.
AgentFrameworkAgent Wrapper orchestriert die Ausführung
Agent verarbeitet die Nachrichten mithilfe von Agent Framework
AgentFrameworkEventBridge konvertiert Agentupdates in AG-UI Ereignisse
Antworten werden als Server-Sent Events (SSE) zurückübertragen.
Die Verbindung schließt, wenn der Lauf abgeschlossen ist.

Client-seitiger Ablauf

Client sendet HTTP POST-Anforderung an den Serverendpunkt
Server antwortet mit SSE-Stream
Client analysiert eingehende data: Zeilen als JSON-Ereignisse
Jedes Ereignis wird basierend auf seinem Typ angezeigt.
threadId wird zur Wahrung der Gesprächskontinuität erfasst.
Der Stream wird abgeschlossen, wenn das RUN_FINISHED Ereignis eintrifft.

Protokolldetails

Das AG-UI Protokoll verwendet:

HTTP POST zum Senden von Anforderungen
Server-Sent Events (SSE) für Streamingantworten
JSON für die Ereignis serialisierung
Thread-IDs zur Aufrechterhaltung des Gesprächskontexts
Ausführen von IDs zum Nachverfolgen einzelner Ausführungen
Benennung des Ereignistyps: GROßBUCHSTABEN mit Unterstrichen (z. B. RUN_STARTED, TEXT_MESSAGE_CONTENT)
Feldbenennung: camelCase (z. B., threadId, runId, messageId)

Allgemeine Muster

Benutzerdefinierte Serverkonfiguration

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

# Add CORS for web clients
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

add_agent_framework_fastapi_endpoint(app, agent, "/agent")

Mehrere Agenten

app = FastAPI()

weather_agent = Agent(name="weather", ...)
finance_agent = Agent(name="finance", ...)

add_agent_framework_fastapi_endpoint(app, weather_agent, "/weather")
add_agent_framework_fastapi_endpoint(app, finance_agent, "/finance")

Fehlerbehandlung

try:
    async for event in client.send_message(message):
        if event.get("type") == "RUN_ERROR":
            error_msg = event.get("message", "Unknown error")
            print(f"Error: {error_msg}")
            # Handle error appropriately
except httpx.HTTPError as e:
    print(f"HTTP error: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")

Problembehandlung

Verbindung verweigert

Stellen Sie sicher, dass der Server ausgeführt wird, bevor Sie den Client starten:

# Terminal 1
python server.py

# Terminal 2 (after server starts)
python client.py

Authentifizierungsfehler

Stellen Sie sicher, dass Sie bei Azure authentifiziert sind:

az login

Stellen Sie sicher, dass Sie über die richtige Rollenzuweisung für die Azure OpenAI-Ressource verfügen.

Streaming funktioniert nicht

Überprüfen Sie, ob Ihr Client-Timeout angemessen ist:

httpx.AsyncClient(timeout=60.0)  # 60 seconds should be enough

Erhöhen Sie bei lang laufenden Agenten das Timeout entsprechend.

Threadkontext verloren

Der Client verwaltet automatisch die Threadkontinuität. Wenn der Kontext verloren geht:

Überprüfen, ob threadId aus RUN_STARTED Ereignissen erfasst wird
Stellen Sie sicher, dass dieselbe Clientinstanz über alle Nachrichten hinweg verwendet wird
Überprüfen Sie, ob der Server das thread_id bei den nachfolgenden Anfragen empfängt.

Nächste Schritte

Nachdem Sie nun die Grundlagen der AG-UI verstanden haben, können Sie:

Hinzufügen von Back-End-Tools: Erstellen von benutzerdefinierten Funktionstools für Ihre Domäne

Zusätzliche Ressourcen

Feedback

War diese Seite hilfreich?

Last updated on 2025-11-11

Freigeben über

Erste Schritte mit AG-UI

Was Sie erstellen werden

Voraussetzungen

Schritt 1: Erstellen eines AG-UI Servers

Erforderliche Pakete installieren

Servercode

Wichtige Konzepte

Konfigurieren und Ausführen des Servers

Schritt 2: Erstellen eines AG-UI-Clients

Erforderliche Pakete installieren

Kundencode

Wichtige Konzepte

Konfigurieren und Ausführen des Clients

Schritt 3: Testen des vollständigen Systems

Erwartete Ausgabe

Farbkodierte Ausgabe

Funktionsweise

Server-Side Ablauf

Client-seitiger Ablauf

Protokolldetails

Nächste Schritte

Zusätzliche Ressourcen

Voraussetzungen

Schritt 1: Erstellen eines AG-UI Servers

Erforderliche Pakete installieren

Servercode

Wichtige Konzepte

Konfigurieren und Ausführen des Servers

Schritt 2: Erstellen eines AG-UI-Clients

Erforderliche Pakete installieren

Kundencode

Wichtige Konzepte

Konfigurieren und Ausführen des Clients

Schritt 3: Testen des vollständigen Systems

Erwartete Ausgabe

Farbkodierte Ausgabe

Testen mit curl (optional)

Funktionsweise

Server-Side Ablauf

Client-seitiger Ablauf

Protokolldetails

Allgemeine Muster

Benutzerdefinierte Serverkonfiguration

Mehrere Agenten

Fehlerbehandlung

Problembehandlung

Verbindung verweigert

Authentifizierungsfehler

Streaming funktioniert nicht

Threadkontext verloren

Nächste Schritte

Zusätzliche Ressourcen

Feedback

Zusätzliche Ressourcen