Visão Geral das Ferramentas

Todas as ferramentas implementam a tool.Tool interface:

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

As ferramentas funcionais implementam tool.FuncTooladicionalmente:

import "context"

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

A maioria das aplicações cria ferramentas funcionais com functool.New ou functool.MustNew em vez de implementarem FuncTool diretamente. A framework utiliza a assinatura da função Go ou tags struct para construir o esquema exposto ao modelo.

Passe ferramentas ao agente através agent.Config.Toolsde:

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

Ou adicionar ferramentas por cada execução:

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

Para Go, marque uma ferramenta invocável com tool.ApprovalRequiredFunc ou use uma ferramenta que já implemente tool.ApprovalRequiredTool, como a ferramenta shell local. Os pedidos e respostas de aprovação fluem através do middleware de chamadas automáticas da ferramenta, por isso trabalham com fornecedores que retornam chamadas de função local.

Matriz de Suporte ao Prestador

Os fornecedores OpenAI e Azure OpenAI oferecem cada um dois tipos de clientes — Respostas e Conclusão de Chat — com diferentes capacidades de ferramenta. Os clientes Azure OpenAI espelham os seus equivalentes OpenAI. Copilot Studio e A2A funcionam num serviço remoto, pelo que as suas capacidades estão configuradas no agente remoto em vez de através do cliente Agent Framework — não estão listados na matriz.

Matriz de Suporte ao Prestador

Os fornecedores OpenAI e Azure OpenAI oferecem cada um múltiplos tipos de clientes com diferentes capacidades de ferramenta. Os clientes Azure OpenAI espelham os seus equivalentes OpenAI. A coluna Foundry aplica-se a FoundryChatClient — para FoundryAgent, as ferramentas estão configuradas na definição do agente Foundry ( veja O que funciona e o que não funciona com FoundryAgent). Copilot Studio e A2A funcionam num serviço remoto, pelo que as suas capacidades estão configuradas no agente remoto em vez de através do cliente Agent Framework — não estão listados na matriz.

¹ Depende do modelo local escolhido que suporta a chamada da função. ² Integrado no runtime CLI do GitHub Copilot, bloqueado por um gestor de permissões. Superfície diferente da do OpenAI get_shell_tool.

Matriz de Suporte ao Prestador

O Go SDK expõe o Microsoft Foundry através foundryprovider de um espaço e o OpenAI OpenAI/Azure através openaiproviderde . As ferramentas alojadas em tool/hostedtool são declarações: o Go SDK envia-as ao fornecedor, e o fornecedor decide se essa capacidade alojada está disponível.

Chama .AsAIFunction() um AIAgent para o converter numa ferramenta de função que possa ser fornecida a outro 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?"));

Chamar .as_tool() um agente para o converter numa ferramenta funcional que possa ser fornecida a outro 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)

Também pode personalizar o nome da ferramenta, descrição e nome do argumento:

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

Envolva um agente com agenttool.New para o disponibilizar como tool.FuncTool um para outro 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()

Também podes expor o mesmo agente enrolado através do MCP com mcptool.AddTool, porque agenttool.New retorna uma ferramenta de função.