Übersicht über Tools

Alle Tools implementieren die tool.Tool Schnittstelle:

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

Zusätzliche Implementierung tool.FuncToolvon Funktionstools:

import "context"

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

Die meisten Anwendungen erstellen Funktionstools mit functool.New oder functool.MustNew anstatt direkt zu implementieren FuncTool . Das Framework verwendet die Go-Funktionssignatur oder Strukturtags, um das Schema zu erstellen, das für das Modell verfügbar gemacht wird.

Übergeben Sie Tools an den Agenten über 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},
    },
})

Oder fügen Sie Tools pro Ausführung hinzu:

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

Markieren Sie für "Gehe gehe" ein aufrufbares tool.ApprovalRequiredToolTool mit tool.ApprovalRequiredFunc oder verwenden Sie ein Tool, das bereits implementiert wird, z. B. das lokale Shelltool. Genehmigungsanforderungen und -antworten fließen über die automatische Aufruf-Middleware des Tools, sodass sie mit Anbietern arbeiten, die lokale Funktionsaufrufe zurückgeben.

Anbieterunterstützungsmatrix

Die OpenAI- und Azure OpenAI-Anbieter bieten jeweils zwei Clienttypen – Antworten und Chatabschluss – mit unterschiedlichen Toolfunktionen. Azure OpenAI-Clients spiegeln ihre OpenAI-Entsprechungen wieder. Copilot Studio und A2A Agents werden auf einem Remotedienst ausgeführt, sodass ihre Funktionen auf dem Remote-Agent und nicht über den Agent Framework-Client konfiguriert sind – sie sind nicht in der Matrix aufgeführt.

Anbieterunterstützungsmatrix

Die OpenAI- und Azure OpenAI-Anbieter bieten jeweils mehrere Clienttypen mit unterschiedlichen Toolfunktionen. Azure OpenAI-Clients spiegeln ihre OpenAI-Entsprechungen wieder. Die Spalte "Foundry" gilt für FoundryChatClient – für - für FoundryAgent, die Tools werden in der Definition des Foundry-Agents konfiguriert (siehe Was funktioniert und was nicht mit FoundryAgent). Copilot Studio und A2A Agents werden auf einem Remotedienst ausgeführt, sodass ihre Funktionen auf dem Remote-Agent und nicht über den Agent Framework-Client konfiguriert sind – sie sind nicht in der Matrix aufgeführt.

¹ Hängt vom gewählten lokalen Modell ab, das Funktionsaufrufe unterstützt. ² Integriert in die GitHub Copilot CLI-Laufzeit, gated by a permission handler. Unterschiedliche Oberfläche von OpenAI es get_shell_tool.

Anbieterunterstützungsmatrix

Das Go SDK macht Microsoft Foundry durch foundryprovider und OpenAI/Azure OpenAI durch openaiprovider. Gehostete Tools sind tool/hostedtool Deklarationen: Das Go SDK sendet sie an den Anbieter, und der Anbieter entscheidet, ob diese gehostete Funktion verfügbar ist.

Rufen Sie .AsAIFunction() eine AIAgent Funktion auf, um sie in ein Funktionstool zu konvertieren, das einem anderen Agent zur Verfügung gestellt werden kann:

// 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?"));

Rufen Sie .as_tool() einen Agent auf, um ihn in ein Funktionstool zu konvertieren, das einem anderen Agent zur Verfügung gestellt werden kann:

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)

Sie können auch den Toolnamen, die Beschreibung und den Argumentnamen anpassen:

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

Umschließen Sie einen Agent, agenttool.New um ihn als tool.FuncTool einen anderen Agent zur Verfügung zu stellen:

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

Sie können auch denselben umschlossenen Agent über MCP mit mcptool.AddToolverfügbar machen, da agenttool.New ein Funktionstool zurückgegeben wird.