Panoramica degli strumenti

Tutti gli strumenti implementano l'interfaccia tool.Tool :

type Tool interface {
    Name() string
    Description() string
}

Gli strumenti per le funzioni implementano tool.FuncToolanche :

import "context"

type FuncTool interface {
    Tool
    Schema() any
    ReturnSchema() any
    Call(ctx context.Context, arguments string) (any, error)
}

La maggior parte delle applicazioni crea strumenti di funzione con functool.New o functool.MustNew invece di implementare FuncTool direttamente. Il framework usa i tag di firma o struct della funzione Go per compilare lo schema esposto al modello.

Passare gli strumenti all'agente tramite agent.Config.Tools:

a := foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
    Instructions: "You are a helpful assistant.",
    Config: agent.Config{
        Tools: []tool.Tool{weatherTool, calculatorTool},
    },
})

In alternativa, aggiungere strumenti per ogni esecuzione:

resp, err := a.RunText(ctx, "What's the weather?", agent.WithTool(weatherTool)).Collect()

Per Go, contrassegnare uno strumento invocabile con tool.ApprovalRequiredFunc o usare uno strumento che implementa tool.ApprovalRequiredToolgià , ad esempio lo strumento della shell locale. Le richieste di approvazione e le risposte passano attraverso il middleware di chiamata automatica dello strumento, in modo che funzionino con provider che restituiscono chiamate di funzione locali.

Matrice di supporto del provider

I provider OpenAI e Azure OpenAI offrono ognuno due tipi di client, risposte e completamento chat, con diverse funzionalità degli strumenti. I client OpenAI di Azure rispecchiano gli equivalenti OpenAI. Copilot Studio e A2A agenti vengono eseguiti in un servizio remoto in modo che le relative funzionalità siano configurate nell'agente remoto anziché tramite il client di Agent Framework, non sono elencate nella matrice.

Matrice di supporto del provider

I provider OpenAI e Azure OpenAI offrono ognuno più tipi di client con diverse funzionalità degli strumenti. I client OpenAI di Azure rispecchiano gli equivalenti OpenAI. La colonna Foundry si applica a FoundryChatClient : per FoundryAgent, gli strumenti sono configurati nella definizione dell'agente Foundry (vedere Cosa funziona e cosa non funziona con FoundryAgent). Copilot Studio e A2A agenti vengono eseguiti in un servizio remoto in modo che le relative funzionalità siano configurate nell'agente remoto anziché tramite il client di Agent Framework, non sono elencate nella matrice.

¹ Dipende dal modello locale scelto che supporta la chiamata di funzione. ² Integrato nel runtime dell'interfaccia della riga di comando GitHub Copilot, gestito da un gestore di autorizzazioni. Superficie diversa da Quella di get_shell_toolOpenAI.

Matrice di supporto del provider

Go SDK espone Microsoft Foundry tramite foundryprovider e OpenAI/Azure OpenAI tramite openaiprovider. Gli strumenti ospitati in tool/hostedtool sono dichiarazioni: Go SDK li invia al provider e il provider decide se la funzionalità ospitata è disponibile.

Chiamare .AsAIFunction() su un AIAgent oggetto per convertirlo in uno strumento funzione che può essere fornito a un altro agente:

// Create the inner agent with its own tools
AIAgent weatherAgent = new AIProjectClient(
    new Uri("<your-foundry-project-endpoint>"),
    new DefaultAzureCredential())
     .AsAIAgent(
        model: "gpt-4o-mini",
        instructions: "You answer questions about the weather.",
        name: "WeatherAgent",
        description: "An agent that answers questions about the weather.",
        tools: [AIFunctionFactory.Create(GetWeather)]);

// Create the main agent and provide the inner agent as a function tool
AIAgent agent = new AIProjectClient(
    new Uri("<your-foundry-project-endpoint>"),
    new DefaultAzureCredential())
     .AsAIAgent(
        model: "gpt-4o-mini",
        instructions: "You are a helpful assistant.",
        tools: [weatherAgent.AsAIFunction()]);

// The main agent can now call the weather agent as a tool
Console.WriteLine(await agent.RunAsync("What is the weather like in Amsterdam?"));

Chiamare .as_tool() un agente per convertirlo in uno strumento funzione che può essere fornito a un altro agente:

import os
from agent_framework.openai import OpenAIChatCompletionClient
from azure.identity import AzureCliCredential

# Create the inner agent with its own tools
weather_agent = OpenAIChatCompletionClient(
    model=os.environ["AZURE_OPENAI_CHAT_COMPLETION_MODEL"],
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
    credential=AzureCliCredential(),
).as_agent(
    name="WeatherAgent",
    description="An agent that answers questions about the weather.",
    instructions="You answer questions about the weather.",
    tools=get_weather
)

# Create the main agent and provide the inner agent as a function tool
main_agent = OpenAIChatCompletionClient(
    model=os.environ["AZURE_OPENAI_CHAT_COMPLETION_MODEL"],
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
    credential=AzureCliCredential(),
).as_agent(
    instructions="You are a helpful assistant.",
    tools=weather_agent.as_tool()
)

# The main agent can now call the weather agent as a tool
result = await main_agent.run("What is the weather like in Amsterdam?")
print(result.text)

È anche possibile personalizzare il nome, la descrizione e il nome dell'argomento dello strumento:

weather_tool = weather_agent.as_tool(
    name="WeatherLookup",
    description="Look up weather information for any location",
    arg_name="query",
    arg_description="The weather query or location"
)

Eseguire il wrapping di un agente con agenttool.New per renderlo disponibile come per tool.FuncTool un altro agente:

import (
    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/provider/foundryprovider"
    "github.com/microsoft/agent-framework-go/tool"
    "github.com/microsoft/agent-framework-go/tool/agenttool"
)

weatherAgent := foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
    Instructions: "You answer questions about the weather.",
    Config: agent.Config{
        Name:        "WeatherAgent",
        Description: "An agent that answers weather questions.",
        Tools:       []tool.Tool{weatherTool},
    },
})

mainAgent := foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
    Instructions: "You are a helpful assistant.",
    Config: agent.Config{
        Tools: []tool.Tool{agenttool.New(weatherAgent, agenttool.Config{})},
    },
})

resp, err := mainAgent.RunText(ctx, "Should I bring an umbrella to Amsterdam?").Collect()

È anche possibile esporre lo stesso agente di cui è stato eseguito il wrapping tramite MCP con mcptool.AddTool, perché agenttool.New restituisce uno strumento di funzione.