Foundry Hostade Agenter

• .NET 10 SDK eller senare

Installera NuGet-värdpaketet:

dotnet add package Microsoft.Agents.AI.Foundry.Hosting --prerelease
dotnet add package Azure.AI.Projects --prerelease

• Python 3.10 eller senare

Installera värdpaketet för förhandsversion, Foundry-klienten och Azure autentiseringspaketet:

pip install --pre agent-framework-foundry agent-framework-foundry-hosting azure-identity

using Azure.AI.AgentServer.Core;
using Azure.AI.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Foundry.Hosting;

var projectEndpoint = new Uri(Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT")
    ?? throw new InvalidOperationException("FOUNDRY_PROJECT_ENDPOINT is not set."));
var deployment = Environment.GetEnvironmentVariable("AZURE_AI_MODEL_DEPLOYMENT_NAME") ?? "gpt-4o";

AIAgent agent = new AIProjectClient(projectEndpoint, new DefaultAzureCredential())
    .AsAIAgent(
        model: deployment,
        instructions: "You are a helpful AI assistant.",
        name: "my-agent");

var builder = AgentHost.CreateBuilder(args);
builder.Services.AddFoundryResponses(agent);
builder.RegisterProtocol("responses", endpoints => endpoints.MapFoundryResponses());

var app = builder.Build();
app.Run();

AgentHost.CreateBuilder skapar ett programvärd som är förkonfigurerat för värdmiljön Foundry. AddFoundryResponses registrerar din agent med svarsprotokollhanteraren och MapFoundryResponses mappar /responses HTTP-slutpunkten.

import os

from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
from agent_framework_foundry_hosting import ResponsesHostServer
from azure.identity import DefaultAzureCredential

client = FoundryChatClient(
    project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
    model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
    credential=DefaultAzureCredential(),
)

agent = Agent(
    client=client,
    instructions="You are a helpful AI assistant.",
    default_options={"store": False},
)

server = ResponsesHostServer(agent)
server.run()

Omsluter ResponsesHostServer din agent och exponerar den via protokollet Foundry Responses. Om du anger storeFalse i default_options undviks duplicering av konversationshistorik eftersom värdinfrastrukturen hanterar historiken automatiskt.

Spara tillstånd och hantera långvariga konversationer

ResponsesHostServer konfigurerar lagringsplatser som stöds av Foundry som standard. För agenter som inte är arbetsflödesagenter tillhandahåller AgentSessionStoreProvider en FoundryAgentSessionStore. CheckpointStoreProvider tillhandahåller en FoundryCheckpointStore för arbetsflödesagenter. FunctionApprovalStoreProvider tillhandahåller en FoundryFunctionApprovalStore för väntande godkännanden. Dessa lagringsplatser använder Foundry State Store när de är värdbaserade och lokalt Agent Server-tillstånd när du kör lokalt.

Om du vill anpassa lagringen skickar du en StoreProvider till agent_session_store_provider eller function_approval_store_provider. Skicka en ContextScopedStoreProvider till checkpoint_store_provider. Till exempel implementera SessionStore och StoreProvider[SessionStore] för att använda din egen lagring för agentsessioner som inte är kopplad till arbetsflöden.

Importera ResponsesServerOptions från azure.ai.agentserver.responsesoch skicka den till ResponsesHostServer via parametern options . Vilka alternativ för långvariga konversationer som är tillgängliga beror på agenttypen:

ResponsesHostServer utlöser RuntimeError om du aktiverar resilienta bakgrundssvar för en agent som inte är en arbetsflödesagent eller styrbara konversationer för en arbetsflödesagent. För fullständiga implementeringar, se exemplen på anpassad lagring, motståndskraftigt långvarigt arbetsflöde och styrbar långvarig agent.

Med protokollet Anrop i C# implementerar du en anpassad InvocationHandler för att bearbeta inkommande begäranden:

using Azure.AI.AgentServer.Core;
using Azure.AI.AgentServer.Invocations;
using Microsoft.Agents.AI;

var builder = AgentHost.CreateBuilder(args);

builder.Services.AddSingleton<AIAgent, MyAgent>();
builder.Services.AddInvocationsServer();
builder.Services.AddScoped<InvocationHandler, MyInvocationHandler>();

builder.RegisterProtocol("invocations", endpoints => endpoints.MapInvocationsServer());

var app = builder.Build();
app.Run();

Metoden AddInvocationsServer registrerar protokolltjänsterna för anrop. Du implementerar InvocationHandler för att definiera hur din agent bearbetar varje begäran.

För en enkel installation använder du InvocationsHostServer från agent_framework_foundry_hosting paketet. Den omsluter din agent på samma sätt som ResponsesHostServer och hanterar sessionshantering automatiskt:

import os

from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
from agent_framework_foundry_hosting import InvocationsHostServer
from azure.identity import DefaultAzureCredential

client = FoundryChatClient(
    project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
    model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
    credential=DefaultAzureCredential(),
)

agent = Agent(
    client=client,
    instructions="You are a friendly assistant. Keep your answers brief.",
    default_options={"store": False},
)

server = InvocationsHostServer(agent)
server.run()

För fullständig kontroll över hanteringen av förfrågningar, använder du InvocationAgentServerHost från azure.ai.agentserver.invocations-paketet direkt och implementerar din egen anroparhanterare.

import os
from collections.abc import AsyncGenerator

from agent_framework import Agent, AgentSession
from agent_framework.foundry import FoundryChatClient
from azure.ai.agentserver.invocations import InvocationAgentServerHost
from azure.identity import DefaultAzureCredential
from starlette.requests import Request
from starlette.responses import JSONResponse, Response, StreamingResponse

_sessions: dict[str, AgentSession] = {}

client = FoundryChatClient(
    project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
    model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
    credential=DefaultAzureCredential(),
)

agent = Agent(
    client=client,
    instructions="You are a friendly assistant. Keep your answers brief.",
    default_options={"store": False},
)

app = InvocationAgentServerHost()


@app.invoke_handler
async def handle_invoke(request: Request):
    """Handle streaming multi-turn chat."""
    data = await request.json()
    session_id = request.state.session_id
    stream = data.get("stream", False)
    user_message = data.get("message", None)

    if user_message is None:
        return Response(content="Missing 'message' in request", status_code=400)

    session = _sessions.setdefault(session_id, AgentSession(session_id=session_id))

    if stream:

        async def stream_response() -> AsyncGenerator[str]:
            async for update in agent.run(user_message, session=session, stream=True):
                yield update.text

        return StreamingResponse(
            stream_response(),
            media_type="text/event-stream",
            headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
        )

    response = await agent.run([user_message], session=session, stream=stream)
    return JSONResponse({"response": response.text})


if __name__ == "__main__":
    app.run()