Paso 7: Aloja tu agente

Hospedaje en ASP.NET Core

Agent Framework proporciona bibliotecas de hospedaje que permiten integrar agentes de inteligencia artificial en aplicaciones ASP.NET Core. Estas bibliotecas simplifican el registro, la configuración y la exposición de agentes a través de varios protocolos.

Como se describe en Agentes, AIAgent es la abstracción fundamental del agente en Agent Framework. Define un "contenedor LLM" que procesa las entradas del usuario, toma decisiones, llama a herramientas y realiza un trabajo adicional para ejecutar acciones y generar respuestas. La exposición de agentes de IA desde la aplicación ASP.NET Core no es trivial. Las bibliotecas de hospedaje resuelven esto mediante el registro de agentes de INTELIGENCIA ARTIFICIAL en un contenedor de inserción de dependencias, lo que le permite resolverlos y usarlos en los servicios de aplicación. También le permiten administrar dependencias del agente, como herramientas y almacenamiento de sesión, desde el mismo contenedor. Los agentes se pueden hospedar junto con la infraestructura de la aplicación, independientemente de los protocolos que usan. Del mismo modo, los flujos de trabajo se pueden hospedar y aprovechar la infraestructura común de la aplicación.

Biblioteca de hospedaje principal

La Microsoft.Agents.AI.Hosting biblioteca es la base para hospedar agentes de inteligencia artificial en ASP.NET Core. Proporciona extensiones para IHostApplicationBuilder registrar y configurar agentes y flujos de trabajo de IA. En ASP.NET Core, IHostApplicationBuilder es el tipo fundamental que representa el generador de aplicaciones y servicios hospedados, la administración de la configuración, el registro, la duración, etc.

Antes de configurar agentes o flujos de trabajo, registre un IChatClient en el contenedor de inserción de dependencias. En los ejemplos siguientes, se registra como singleton con clave bajo el nombre chat-model:

// endpoint is your Microsoft Foundry project endpoint
// deploymentName is 'gpt-4o-mini' for example

IChatClient chatClient = new AIProjectClient(
        new Uri(endpoint),
        new DefaultAzureCredential())
    .GetProjectOpenAIClient()
    .GetProjectResponsesClient()
    .AsIChatClient(deploymentName);
builder.Services.AddSingleton(chatClient);

AddAIAgent

Registro de un agente de IA con inserción de dependencias:

var pirateAgent = builder.AddAIAgent(
    "pirate",
    instructions: "You are a pirate. Speak like a pirate",
    description: "An agent that speaks like a pirate.",
    chatClientServiceKey: "chat-model");

El AddAIAgent() método devuelve un IHostedAgentBuilder, que proporciona métodos de extensión para configurar el agente. Por ejemplo, puede agregar herramientas al agente:

var pirateAgent = builder.AddAIAgent("pirate", instructions: "You are a pirate. Speak like a pirate")
    .WithAITool(new MyTool()); // MyTool is a custom type derived from AITool

También puede configurar el almacén de sesiones (almacenamiento para datos de conversación):

var pirateAgent = builder.AddAIAgent("pirate", instructions: "You are a pirate. Speak like a pirate")
    .WithInMemorySessionStore();

AddWorkflow

Registre flujos de trabajo que coordinan varios agentes. Un flujo de trabajo es básicamente un "grafo" donde cada nodo es un AIAgenty los agentes se comunican entre sí.

En este ejemplo, dos agentes funcionan secuencialmente. La entrada del usuario se envía primero a agent-1, que genera una respuesta y la envía a agent-2. A continuación, el flujo de trabajo genera la respuesta final. También hay un BuildConcurrent método que crea un flujo de trabajo de agente simultáneo.

builder.AddAIAgent("agent-1", instructions: "you are agent 1!");
builder.AddAIAgent("agent-2", instructions: "you are agent 2!");

var workflow = builder.AddWorkflow("my-workflow", (sp, key) =>
{
    var agent1 = sp.GetRequiredKeyedService<AIAgent>("agent-1");
    var agent2 = sp.GetRequiredKeyedService<AIAgent>("agent-2");
    return AgentWorkflowBuilder.BuildSequential(key, [agent1, agent2]);
});

Exposición del flujo de trabajo como AIAgent

Para usar integraciones de protocolo (como A2A o OpenAI) con un flujo de trabajo, conviértalo en un agente independiente. Actualmente, los flujos de trabajo no proporcionan funcionalidades de integración similares por sí mismas, por lo que se requiere este paso de conversión:

var workflowAsAgent = builder
    .AddWorkflow("science-workflow", (sp, key) => { ... })
    .AddAsAIAgent();  // Now the workflow can be used as an agent

Detalles de implementación

Las bibliotecas de hospedaje actúan como adaptadores de protocolo que puenten protocolos de comunicación externos y la implementación interna AIAgent de Agent Framework. Cuando se usa una biblioteca de integración de hospedaje, la biblioteca recupera el registro AIAgent de la inserción de dependencias, lo encapsula con middleware específico de protocolo para traducir las solicitudes entrantes y las respuestas salientes e invoca AIAgent para procesar las solicitudes. Esta arquitectura mantiene la implementación del agente independiente de cualquier protocolo.

Por ejemplo, con la biblioteca de hospedaje de ASP.NET Core con el adaptador de protocolo A2A:

// Register the agent
var pirateAgent = builder.AddAIAgent("pirate",
    instructions: "You are a pirate. Speak like a pirate",
    description: "An agent that speaks like a pirate.");

// Expose via a protocol (e.g. A2A)
builder.Services.AddA2AServer();
var app = builder.Build();
app.MapA2AServer();
app.Run();

Microsoft Foundry Hosted Agents es la principal opción de hospedamiento administrado. Complete los pasos previos de Foundry Hosted Agents, incluida la extensión del agente de IA de la CLI de Azure developer y el inicio de sesión en CLI de Azure.

El ejemplo de introducción crea un agente con el almacenamiento del modelo del lado servidor deshabilitado e inicia un ResponsesHostServer:

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


def main() -> None:
    agent = Agent(
        client=FoundryChatClient(
            project_endpoint="https://your-account.services.ai.azure.com/api/projects/your-project",
            model="gpt-6-luna",
            credential=DefaultAzureCredential(),
        ),
        instructions="You are a friendly assistant. Keep your answers brief.",
        default_options={"store": False},
    )
    ResponsesHostServer(agent=agent, history_source="agent_server").run()


if __name__ == "__main__":
    main()

Reemplace el punto de conexión del proyecto codificado de forma fija y el nombre de implementación del modelo y, a continuación, ejecute el ejemplo PEP 723 localmente desde la raíz del repositorio de Agent Framework:

uv run python/samples/01-get-started/07_hosting.py

Para implementar un proyecto de agente hospedado completo, inicialícelo desde el ejemplo mantenido azure.yaml:

mkdir my-hosted-agent && cd my-hosted-agent
azd ai agent init -t https://github.com/microsoft-foundry/foundry-samples/blob/main/samples/python/hosted-agents/agent-framework/responses/01-basic/azure.yaml --src .

Ejecute el host del agente:

azd ai agent run

En otro terminal, invoque al agente local:

azd ai agent invoke --local "Hello!"

Hospedaje con protocolo A2A

La adaptación a Go proporciona hospedamiento A2A a través de a2aprovider, que envuelve un agente en un controlador HTTP compatible con el protocolo Agent-to-Agent.

Cree un agente:

import (
    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/provider/a2aprovider"
    "github.com/microsoft/agent-framework-go/provider/foundryprovider"

    "github.com/a2aproject/a2a-go/v2/a2a"
    "github.com/a2aproject/a2a-go/v2/a2asrv"
)

a := foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
    Instructions: "You are a helpful assistant.",
    Config: agent.Config{
    },
})

Exponga el agente a través de A2A:

url := "http://localhost:5000"
card := &a2a.AgentCard{
    Name:               "MyAgent",
    Description:        "A helpful assistant.",
    Version:            "1.0.0",
    DefaultInputModes:  []string{"text"},
    DefaultOutputModes: []string{"text"},
    Capabilities:       a2a.AgentCapabilities{Streaming: false},
    SupportedInterfaces: []*a2a.AgentInterface{
        a2a.NewAgentInterface(url, a2a.TransportProtocolJSONRPC),
    },
}

mux := http.NewServeMux()
requestHandler := a2asrv.NewHandler(
    a2aprovider.NewExecutor(a, a2aprovider.ExecutorConfig{}),
    a2asrv.WithExtendedAgentCard(card),
)
mux.Handle("/", a2asrv.NewJSONRPCHandler(requestHandler))
mux.Handle(a2asrv.WellKnownAgentCardPath, a2asrv.NewStaticAgentCardHandler(card))

log.Println("A2A server listening on :5000")
http.ListenAndServe(":5000", mux)