Agent mit einem Funktionstool

Erfahren Sie, wie Sie einen Agent mit einem Tool für benutzerdefinierte Funktionen erstellen.

Beispiel für Wetteragent

In diesem Beispiel haben wir einen Wetteragent, der mit einem benutzerdefinierten Funktionstool ausgestattet ist. Dies wird auch als Funktionsaufruf-Agent bezeichnet.

Mit Funktionstools kann ein Agent benutzerdefinierte, lokal definierte Funktionen als Tools verwenden. Funktionstools sind flexibel und besonders nützlich für Unternehmensanwendungsfälle aufgrund ihrer lokalen Verarbeitung, einfachen Authentifizierung und nahtlosen Integration mit vorhandenen Funktionsfunktionen.

---

Info: Funktionstools werden lokal auf Ihrer Seite ausgeführt.

Was auf der OCI-Serverseite an den Remote-Agent gesendet wird, ist die Funktionsdefinition (Funktionsname, Funktionsparameter und deren Beschreibungen). OCI-Server greifen nicht auf die Funktionsimplementierung zu.

---

Python

weather_agent.py

from typing import Dict, Any
from oci.addons.adk import Agent, AgentClient, tool

@tool
def get_weather(location: str) -> Dict[str, Any]:
    """Get the weather for a given location.

    Args:
      location(str): The location for which weather is queried
    """
    return {"location": location, "temperature": 72, "unit": "F"}


def main():
    client = AgentClient(
        auth_type="api_key",
        profile="DEFAULT",
        region="us-chicago-1"
    )

    agent = Agent(
        client=client,
        agent_endpoint_id="ocid1...",
        instructions="Perform weather queries using the given tools",
        tools=[get_weather]
    )

    agent.setup()

    input = "Is it cold in Seattle?"
    response = agent.run(input)

    response.pretty_print()

if __name__ == "__main__":
    main()

Java

WeatherAgent.java

package demos.singleTurnSingleTool.WeatherAgent;

import com.oracle.bmc.ConfigFileReader;
import com.oracle.bmc.adk.agent.Agent;
import com.oracle.bmc.adk.agent.RunOptions;
import com.oracle.bmc.adk.client.AgentClient;
import com.oracle.bmc.adk.tools.FunctionTool;
import com.oracle.bmc.adk.run.RunResponse;
import com.oracle.bmc.auth.BasicAuthenticationDetailsProvider;
import com.oracle.bmc.auth.SessionTokenAuthenticationDetailsProvider;

import java.lang.reflect.Method;
import java.util.Arrays;

public class WeatherAgent {
    @Tool(name = "getWeather", description = "Get weather of a given location")
    public static Map<String, String> getWeather(
            @Param(description = "The location") String location) {
        Map<String, String> weather = new HashMap<>();
        weather.put("location", location);
        weather.put("temperature", "72");
        weather.put("unit", "F");
        return weather;
    }

  public static void main(String[] args) throws Exception {
    final String configLocation = "~/.oci/config";
    final String configProfile = "DEFAULT";

    BasicAuthenticationDetailsProvider authProvider =
            new SessionTokenAuthenticationDetailsProvider(
                    ConfigFileReader.parse(configLocation, configProfile));

    AgentClient agentClient = AgentClient.builder()
        .authProvider(authProvider)
        .region("us-chicago-1")
        .build();

    FunctionTool getWeatherTool =
        FunctionTool.fromMethod(WeatherAgent.class, "getWeather", String.class);

    Agent agent = Agent.builder()
        .client(agentClient)
        .agentEndpointId("YOUR_AGENT_ENDPOINT_ID")
        .instructions("Perform weather queries using the given tools.")
        .tools(Arrays.asList(getWeatherTool))
        .build();

    agent.setup();
    final String input = "Is it cold in Seattle";
    final Integer maxStep = 3;
    RunOptions runOptions = RunOptions.builder().maxSteps(maxStep).build();
    RunResponse response = agent.run(input, runOptions);
    response.prettyPrint();
  }
}

Sie schreiben eine einfache Funktion get_weather, dekorieren sie mit @tool und verwenden Standard-Docstring, um Funktionsbeschreibung und Parameterbeschreibungen zu schreiben.

Ihre Funktion kann alle Elemente zurückgeben, die in eine Zeichenfolge konvertiert werden können. Hier wird nur ein Dict zurückgegeben, das ein JSON-Objekt simuliert, das wir von einem Datenbank-, Cache- oder API-Endpunkt erhalten.

Sie übergeben diese Funktion dann an die Liste tools, wenn Sie das Objekt Agent erstellen. Dadurch wird die Funktion lokal als Tool für den Agent registriert.

Wenn Sie die Methode agent.setup() ausführen, wendet ADK das Setup des lokalen Agents auf die Remote-Agent-Instanz an. Diese umfasst die Agent-Anweisungen und das Funktionstool. Das ADK generiert automatisch das Funktions-JSON-Schema, das zum Einrichten des benutzerdefinierten Funktionstools auf dem Server erforderlich ist.

Wenn Sie die Methode agent.run() ausführen, verarbeitet das ADK die Client/Server-Interaktion, die für den Funktionsaufruf erforderlich ist. Dazu gehört der Aufruf der Funktion get_weather.

Funktionsweise

Wenn der Remote-Agent beschließt, das Tool get_weather zu verwenden, antwortet er mit einer Antwort, die eine erforderliche Aktion enthält, die der Client ausführen muss. In diesem Fall muss der Client das Funktionstool get_weather mit dem Argument location=Seattle aufrufen.

Der Remote-Agent wendet die Intent-Klassifizierung an, um das Tool get_weather und die Argumentslot-Füllung basierend auf der natürlichen Sprachabfrage Is it cold in Seattle? zu verwenden.

ADK parst die erforderliche Aktion, sucht die registrierte lokale Funktion, führt diese Funktion mit den angegebenen Argumenten aus, erfasst die Ausgabe des Funktionsaufrufs und leitet die Ausgabe an den Remote-Agent zurück. Der Agent kann diese Ausgabe verwenden, um eine Antwort auf die Frage des Benutzers zu generieren.