Első lépések az AG-UI

Ez az oktatóanyag bemutatja, hogyan hozhat létre kiszolgáló- és ügyfélalkalmazásokat a AG-UI protokoll használatával a .NET vagy a Python és az Agent Framework használatával. Megtudhatja, hogyan hozhat létre egy AG-UI kiszolgálót, amely egy AI-ügynököt és egy hozzá csatlakozó ügyfelet üzemeltet interaktív beszélgetésekhez.

Mit fog felépíteni?

Az oktatóanyag végére a következőkre lesz szüksége:

HTTP-en keresztül elérhető AI-ügynököt üzemeltető AG-UI-kiszolgáló
Egy ügyfélalkalmazás, amely a kiszolgálóhoz csatlakozik, és a válaszokat streameli
A AG-UI protokoll és az Agent Framework működésének ismertetése

Előfeltételek

Mielőtt hozzákezdene, győződjön meg arról, hogy a következők vannak:

.NET 8.0 vagy újabb
Azure OpenAI szolgáltatásvégpont és üzembe helyezés konfigurálva
Azure CLI telepítve és hitelesítve
A felhasználó rendelkezik az Cognitive Services OpenAI Contributor Azure OpenAI-erőforrás szerepkörével

Megjegyzés:

Ezek a minták Azure OpenAI-modelleket használnak. További információ: Azure OpenAI-modellek üzembe helyezése az Azure AI Foundryvel.

Megjegyzés:

Ezek a minták hitelesítéshez használatosak DefaultAzureCredential . Győződjön meg arról, hogy hitelesítve van az Azure-ral (pl. keresztül az login). További információkért tekintse meg az Azure Identity dokumentációját.

Figyelmeztetés

A AG-UI protokoll még fejlesztés alatt áll, és változhat. Ezeket a mintákat a protokoll fejlődésével folyamatosan frissítjük.

1. lépés: AG-UI-kiszolgáló létrehozása

A AG-UI-kiszolgáló üzemelteti az AI-ügynököt, és HTTP-végpontokon keresztül teszi elérhetővé a ASP.NET Core használatával.

Megjegyzés:

A kiszolgálóprojekthez az Microsoft.NET.Sdk.Web SDK szükséges. Amikor új projektet hoz létre az alapoktól, használja a dotnet new web-t, vagy győződjön meg arról, hogy a .csproj fájl a <Project Sdk="Microsoft.NET.Sdk.Web"> helyett a Microsoft.NET.Sdk-t használja.

A szükséges csomagok telepítése

Telepítse a kiszolgálóhoz szükséges csomagokat:

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

Megjegyzés:

A Microsoft.Extensions.AI.OpenAI csomag szükséges ahhoz a AsIChatClient() bővítménymetódushoz, amely az OpenAI-t ChatClient az IChatClient Agent Framework által várt felületre konvertálja.

Kiszolgálókód

Hozzon létre egy fájlt: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();

Alapfogalmak

AddAGUI: Regisztrálja az AG-UI szolgáltatásokat a függőséginjektálási tárolóban
MapAGUI: A AG-UI végpontot automatikus kérés-/válaszkezeléssel és SSE-streameléssel regisztráló bővítménymetódus
ChatClient és AsIChatClient(): AzureOpenAIClient.GetChatClient() az OpenAI ChatClient típusát adja vissza. A AsIChatClient() bővítménymetódus (a Microsoft.Extensions.AI.OpenAI-ból) átalakítja az Agent Framework által megkövetelt IChatClient felületté.
AsAIAgent: Létrehoz egy Agent Framework-ügynököt egy IChatClient
ASP.NET Core-integráció: A ASP.NET Core natív aszinkron támogatását használja a streamelési válaszokhoz
Utasítások: Az ügynök alapértelmezett utasításokat tartalmaz, amelyeket az ügyfélüzenetek felülírhatnak
Konfiguráció: AzureOpenAIClient biztonságos hitelesítéssel DefaultAzureCredential

A kiszolgáló konfigurálása és futtatása

Adja meg a szükséges környezeti változókat:

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

Futtassa a kiszolgálót:

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

A kiszolgáló elkezd figyelni http://localhost:8888-on.

Megjegyzés:

Tartsa futva a kiszolgálót, miközben az ügyfél beállítása és futtatása történik a 2. lépés során. A teljes rendszer működéséhez a kiszolgálónak és az ügyfélnek is egyszerre kell futnia.

2. lépés: AG-UI-ügyfél létrehozása

A AG-UI ügyfél csatlakozik a távoli kiszolgálóhoz, és megjeleníti a streamelési válaszokat.

Fontos

Az ügyfél futtatása előtt győződjön meg arról, hogy a AG-UI kiszolgáló az 1. lépésben fut http://localhost:8888.

A szükséges csomagok telepítése

Telepítse a AG-UI ügyfélkódtárat:

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

Megjegyzés:

A Microsoft.Agents.AI csomag biztosítja a AsAIAgent() bővítménymetódust.

Ügyfélkód

Hozzon létre egy fájlt: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}");
}

Alapfogalmak

Server-Sent események (SSE):: A protokoll az SSE-t használja a streamelési válaszokhoz
AGUIChatClient: Ügyfélosztály, amely AG-UI kiszolgálókhoz és implementálásokhoz csatlakozik IChatClient
AsAIAgent: Bővítménymetódus az AGUIChatClient ügynök ügyfélből való létrehozásához
RunStreamingAsync: A válaszokat objektumként AgentResponseUpdate streameli
AsChatResponseUpdate: Bővítménymetódus a csevegéshez tartozó tulajdonságok, mint ConversationId és ResponseId eléréséhez.
Munkamenet-kezelés: A AgentSession beszélgetési környezet fenntartása a kérelmek között
Tartalomtípusok: A válaszok az üzenetekre és TextContent a hibákra is kiterjednek ErrorContent

Az ügyfél konfigurálása és futtatása

Igény szerint egyéni kiszolgáló URL-címét is beállíthatja:

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

Futtassa a klienst egy külön terminálon (ellenőrizze, hogy az 1. lépésben szereplő kiszolgáló fut):

dotnet run

3. lépés: A teljes rendszer tesztelése

A kiszolgáló és az ügyfél futtatásával most már tesztelheti a teljes rendszert.

Várt kimenet

$ 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

Színkódolt kimenet

Az ügyfél különböző tartalomtípusokat jelenít meg különböző színekkel:

Sárga: Elindított értesítések futtatása
Cián: Ügynök szöveges válaszai (valós időben streamelve)
Zöld: Befejezési értesítések futtatása
Piros: Hibaüzenetek

Hogyan működik?

Server-Side folyamatmenet

Az ügyfél HTTP POST-kérést küld üzenetekkel
ASP.NET Core-végpont a kérést a következőn keresztül kapja meg: MapAGUI
Az Ügynök az Agent Framework használatával dolgozza fel az üzeneteket
A válaszok AG-UI eseményekké alakulnak
Az eseményeket visszaküldve streameljük, mint "Server-Sent Events" (SSE)
A kapcsolat bezárul, amikor a futtatás befejeződik

Ügyféloldali műveletfolyam

AGUIChatClient HTTP POST-kérés küldése a kiszolgálóvégpontra
A kiszolgáló SSE-adatfolyammal válaszol
Az ügyfél objektumokba elemzi a AgentResponseUpdate bejövő eseményeket
Minden frissítés a tartalomtípusa alapján jelenik meg
ConversationId a beszélgetés folytonosságának biztosítása érdekében kerül rögzítésre
A stream befejeződik a futtatás befejezésekor

Protokoll részletei

A AG-UI protokoll a következőket használja:

HTTP POST kérések küldéséhez
A szerver által küldött események (SSE) használata a válaszok streameléséhez.
JSON az esemény szerializálásához
Témaazonosítók (mint ConversationId) a beszélgetési környezet fenntartásához
Azonosítók futtatása (mint ResponseId) az egyes végrehajtások nyomon követéséhez

Következő lépések

Most, hogy megismerte az AG-UI alapjait, a következőt teheti:

Háttéreszközök hozzáadása: Egyéni függvényeszközök létrehozása a tartományhoz

További források

Előfeltételek

Mielőtt hozzákezdene, győződjön meg arról, hogy a következők vannak:

Python 3.10 vagy újabb
Azure OpenAI szolgáltatásvégpont és üzembe helyezés konfigurálva
Azure CLI telepítve és hitelesítve
A felhasználó rendelkezik az Cognitive Services OpenAI Contributor Azure OpenAI-erőforrás szerepkörével

Megjegyzés:

Ezek a minták Azure OpenAI-modelleket használnak. További információ: Azure OpenAI-modellek üzembe helyezése az Azure AI Foundryvel.

Megjegyzés:

Figyelmeztetés

A AG-UI protokoll még fejlesztés alatt áll, és változhat. Ezeket a mintákat a protokoll fejlődésével folyamatosan frissítjük.

1. lépés: AG-UI-kiszolgáló létrehozása

A AG-UI-kiszolgáló üzemelteti az AI-ügynököt, és a FastAPI használatával HTTP-végpontokon keresztül teszi elérhetővé.

A szükséges csomagok telepítése

Telepítse a kiszolgálóhoz szükséges csomagokat:

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

Vagy uv:

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

Ez automatikusan telepíti agent-framework-core, fastapi, és uvicorn függőségként.

Kiszolgálókód

Hozzon létre egy fájlt: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)

Alapfogalmak

add_agent_framework_fastapi_endpoint: A AG-UI végpont regisztrálása automatikus kérés-/válaszkezeléssel és SSE-streameléssel
Agent: Az ügynök-keretrendszer, amely a bejövő kéréseket kezeli
FastAPI-integráció: A FastAPI natív aszinkron támogatását használja a streamelési válaszokhoz
Utasítások: Az ügynök alapértelmezett utasításokat tartalmaz, amelyeket az ügyfélüzenetek felülírhatnak
Konfiguráció: AzureOpenAIChatClient beolvassa a környezeti változókat, vagy közvetlenül fogadja el a paramétereket

A kiszolgáló konfigurálása és futtatása

Adja meg a szükséges környezeti változókat:

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

Futtassa a kiszolgálót:

python server.py

Vagy használja közvetlenül az uvicorn-t:

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

A kiszolgáló elkezd figyelni http://127.0.0.1:8888-on.

2. lépés: AG-UI-ügyfél létrehozása

A AG-UI ügyfél csatlakozik a távoli kiszolgálóhoz, és megjeleníti a streamelési válaszokat.

A szükséges csomagok telepítése

A AG-UI csomag már telepítve van, amely tartalmazza a AGUIChatClientkövetkezőket:

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

Ügyfélkód

Hozzon létre egy fájlt: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())

Alapfogalmak

Server-Sent események (SSE):: A protokoll SSE formátumot használ (data: {json}\n\n)
Eseménytípusok: A különböző események metaadatokat és tartalmat biztosítanak (NAGYBETŰ aláhúzással):
- RUN_STARTED: Az ügynök megkezdte a feldolgozást
- TEXT_MESSAGE_START: Az ügynöktől érkező szöveges üzenet kezdete
- TEXT_MESSAGE_CONTENT: Inkrementális szöveg streamelve az ügynöktől (mezővel delta)
- TEXT_MESSAGE_END: Szöveges üzenet vége
- RUN_FINISHED: Sikeres befejezés
- RUN_ERROR: Hibainformációk
Mezőelnevezés: Az eseménymezők a camelCaset használják (pl. threadId, , runId) messageId
Szálkezelés: A threadId segít fenntartani a beszélgetési környezetet a kérések között
Client-Side utasítások: A rendszerüzenetek az ügyféltől érkeznek

Az ügyfél konfigurálása és futtatása

Igény szerint egyéni kiszolgáló URL-címét is beállíthatja:

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

Futtassa a klienst (egy külön terminálban):

python client.py

3. lépés: A teljes rendszer tesztelése

A kiszolgáló és az ügyfél futtatásával most már tesztelheti a teljes rendszert.

Várt kimenet

$ 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

Színkódolt kimenet

Az ügyfél különböző tartalomtípusokat jelenít meg különböző színekkel:

Sárga: Elindított értesítések futtatása
Cián: Ügynök szöveges válaszai (valós időben streamelve)
Zöld: Befejezési értesítések futtatása
Piros: Hibaüzenetek

Tesztelés curl használatával (nem kötelező)

Az ügyfél futtatása előtt manuálisan tesztelheti a kiszolgálót a curl használatával:

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?"}
    ]
  }'

Látni kell, hogy a Server-Sent események visszaáramlanak.

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":"..."}

Hogyan működik?

Server-Side folyamatmenet

Az ügyfél HTTP POST-kérést küld üzenetekkel
A FastAPI-végpont megkapja a kérést
AgentFrameworkAgent wrapper irányítja a végrehajtást
Az Ügynök az Agent Framework használatával dolgozza fel az üzeneteket
AgentFrameworkEventBridge az ügynökfrissítéseket AG-UI eseményekké alakítja
A válaszok Server-Sent eseményekként (SSE) lesznek továbbítva
A kapcsolat bezárul, amikor a futtatás befejeződik

Ügyféloldali műveletfolyam

Az ügyfél HTTP POST-kérést küld a kiszolgálóvégpontnak
A kiszolgáló SSE-adatfolyammal válaszol
Az ügyfél JSON-eseményekként elemzi a bejövő data: sorokat
Minden esemény a típusától függően jelenik meg
threadId a beszélgetés folytonosságának biztosítása érdekében kerül rögzítésre
A stream akkor fejeződik be, amikor RUN_FINISHED az esemény megérkezik

Protokoll részletei

A AG-UI protokoll a következőket használja:

HTTP POST kérések küldéséhez
A szerver által küldött események (SSE) használata a válaszok streameléséhez.
JSON az esemény szerializálásához
Témaazonosítók a beszélgetési környezet fenntartásához
Azonosítók futtatása az egyes végrehajtások nyomon követéséhez
Eseménytípus elnevezése: NAGYBETŰVEL és aláhúzásjelekkel (pl. RUN_STARTED, TEXT_MESSAGE_CONTENT)
Mező elnevezése: camelCase (pl. threadId, runId, messageId)

Gyakori minták

Egyéni kiszolgáló konfigurálása

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")

Több ügynök

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")

Hibakezelés

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}")

Hibaelhárítás

A kapcsolat elutasítva

Győződjön meg arról, hogy a kiszolgáló fut az ügyfél indítása előtt:

# Terminal 1
python server.py

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

Hitelesítési hibák

Győződjön meg arról, hogy hitelesítve van az Azure-ral:

az login

Ellenőrizze, hogy rendelkezik-e a megfelelő szerepkör-hozzárendeléssel az Azure OpenAI-erőforráson.

A streamelés nem működik

Ellenőrizze, hogy az ügyfél időtúllépése elegendő-e:

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

Hosszú ideig futó ügynökök esetén ennek megfelelően növelje az időtúllépést.

A szál kontextusa veszett el

Az ügyfél automatikusan kezeli a szál folytonosságát. Ha az összefüggés elveszett:

Annak ellenőrzése, hogy threadId az eseményekről RUN_STARTED van-e rögzítve
Győződjön meg arról, hogy ugyanazt az ügyfélpéldányt használja az üzenetek között
Ellenőrizze, hogy a kiszolgáló megkapja-e a thread_id-t a következő kérésekben.

Következő lépések

Most, hogy megismerte az AG-UI alapjait, a következőt teheti:

Háttéreszközök hozzáadása: Egyéni függvényeszközök létrehozása a tartományhoz

További források

Visszacsatolás

Hasznos volt ez az oldal?

Last updated on 2025-11-11

Megosztás:

Első lépések az AG-UI

Mit fog felépíteni?

Előfeltételek

1. lépés: AG-UI-kiszolgáló létrehozása

A szükséges csomagok telepítése

Kiszolgálókód

Alapfogalmak

A kiszolgáló konfigurálása és futtatása

2. lépés: AG-UI-ügyfél létrehozása

A szükséges csomagok telepítése

Ügyfélkód

Alapfogalmak

Az ügyfél konfigurálása és futtatása

3. lépés: A teljes rendszer tesztelése

Várt kimenet

Színkódolt kimenet

Hogyan működik?

Server-Side folyamatmenet

Ügyféloldali műveletfolyam

Protokoll részletei

Következő lépések

További források

Előfeltételek

1. lépés: AG-UI-kiszolgáló létrehozása

A szükséges csomagok telepítése

Kiszolgálókód

Alapfogalmak

A kiszolgáló konfigurálása és futtatása

2. lépés: AG-UI-ügyfél létrehozása

A szükséges csomagok telepítése

Ügyfélkód

Alapfogalmak

Az ügyfél konfigurálása és futtatása

3. lépés: A teljes rendszer tesztelése

Várt kimenet

Színkódolt kimenet

Tesztelés curl használatával (nem kötelező)

Hogyan működik?

Server-Side folyamatmenet

Ügyféloldali műveletfolyam

Protokoll részletei

Gyakori minták

Egyéni kiszolgáló konfigurálása

Több ügynök

Hibakezelés

Hibaelhárítás

A kapcsolat elutasítva

Hitelesítési hibák

A streamelés nem működik

A szál kontextusa veszett el

Következő lépések

További források

Visszacsatolás

További források