Funktionsaufrufe mit SDKs in generativen KI-Agents

Verwenden Sie diese Dokumentation, um sich mit der Verwendung des OCI-Java-SDKs zur Integration von Funktionsaufrufen in eine Anwendung vertraut zu machen. Die folgenden Schritte zeigen ein Beispiel für ein OCI-Java-SDK zum Erstellen eines Funktionstools und zum Aufrufen des Funktionstools mit Chat.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie die folgenden Ressourcen eingerichtet haben:

Ein Agent. Siehe Agent in Generative AI Agents erstellen.
Ein Agent-Endpunkt. Siehe Endpunkt in generativen KI-Agents erstellen.
Das erforderliche OCI-SDK und die in Ihrer Entwicklungsumgebung installierten Abhängigkeiten. Siehe Setup und Voraussetzungen.

Funktionstool erstellen

Die folgenden Schritte zeigen, wie Sie mit dem OCI-Java-SDK ein Funktionstool für einen Agent erstellen.

Konfigurieren Sie den Client. Beispiel:

GenerativeAiAgentRuntimeClient agentClient = GenerativeAiAgentRuntimeClient.builder()
       .endpoint(endpoint)
       .configuration(clientConfiguration)
       .build(provider);

Definieren Sie eine Funktion, und betten Sie die Funktion dann in ToolConfig ein. Beispiel: Hier ist eine Funktion, mit der ein OCI Object Storage-Bucket erstellt wird:

private static Function prepareFunction() throws JsonProcessingException {

        String payload="{\n" +
        "                \"type\": \"object\",\n" +
        "                \"properties\": {\n" +
        "                    \"bucket_name\": {\n" +
        "                        \"type\": \"string\",\n" +
        "                        \"description\": \"The name of the bucket to create.\"\n" +
        "                    },\n" +
        "                    \"compartment_ocid\": {\n" +
        "                        \"type\": \"string\",\n" +
        "                        \"description\": \"The OCID of the compartment where the bucket will be created.\"\n" +
        "                    },\n" +
        "                    \"storage_tier\": {\n" +
        "                        \"type\": \"string\",\n" +
        "                        \"enum\": [\"Standard\", \"Archive\"],\n" +
        "                        \"description\": \"The storage tier for the bucket.\"\n" +
        "                    }\n" +
        "                },\n" +
        "                \"required\": [\"bucket_name\", \"compartment_ocid\"],\n" +
        "                \"additionalProperties\": \"false\" \n" +
        "            }\n";

        ObjectMapper objectMapper = new ObjectMapper();
        
        Map<String,String> parameters = objectMapper.readValue(payload, HashMap.class);

        for (Map.Entry entry : parameters.entrySet()) {
                String jsonString = objectMapper.writeValueAsString(entry.getValue());
                entry.setValue(jsonString);
        }
        return Function.builder()
                .name("object_storage")
                .description("A function to create object storage bucket")
                .parameters(parameters)
                .build();            
}
 
private static ToolConfig createFunctionToolConfig() {
        return FunctionCallingToolConfig.builder()
                .function(prepareFunction())
                .build();
}

Erstellen Sie eine Toolanforderung, und erstellen Sie das Tool dann mit dem Client. Beispiel:

CreateToolDetails createToolDetails = CreateToolDetails.builder()
                .agentId(agentId)
                .compartmentId(COMPARTMENT_ID)
                .toolConfig(toolConfig)
                .displayName("tool-sdk")
                .description("tool description")
                .build();
 CreateToolRequest toolRequest = CreateToolRequest.builder()
                 .createToolDetails(createToolDetails)
                 .build();
client.createTool(toolRequest);

Mit einem Agenten chatten

Um mit einem Agent zu chatten, der über ein Funktionstool verfügt, erstellen Sie zunächst eine Session, und rufen Sie die Funktion in der Session auf. Hier finden Sie einige Beispiele für diese Schritte.

Session erstellen. Beispiel:

GenerativeAiAgentRuntimeClient agentClient = GenerativeAiAgentRuntimeClient.builder()
        .endpoint(endpoint)
        .configuration(clientConfiguration)
        .build(provider);
 
// Create a new chat session request
CreateSessionRequest request = CreateSessionRequest.builder()
        .agentEndpointId(<agentEndpointId>)
        .createSessionDetails(CreateSessionDetails.builder()
                .description("description")
                .displayName("display_name")
                .build())
        .build();
String sessionId = agentClient.createSession(request)
        .getSession()
        .getId();

Ersetzen Sie <agentEndpointId> durch die OCID des Agent-Endpunkts aus dem Abschnitt "Voraussetzungen".

Verwenden Sie die Session, um einen Chataufruf auszuführen, der die Funktion aufruft. Dieses Beispiel sendet eine Nachricht an den Agent und erwartet eine Antwort, die einen Funktionsaufruf enthält

String message = "Create an Object Store.";
 
// Create Chat request
final ChatDetails chatDetails = ChatDetails.builder()
        .shouldStream(shouldStream)
        .userMessage(message)
        .sessionId(sessionId)
        .build();
final ChatRequest chatRequest = ChatRequest.builder()
        .chatDetails(chatDetails)
        .agentEndpointId(agentEndpointId)
        .build();
 
final ChatResult chatResult = agentClient.chat(chatRequest);

Die Antwort vom Agent enthält ein Feld required-actions, das die Details der aufzurufenden Funktion enthält.

chatResult(message=null, traces=[], usageDetails=null, 
requiredActions=[FunctionCallingRequiredAction(super=RequiredAction(super=BmcModel
(__explicitlySet__=[functionCall, actionId])
actionId=<some-action-id>),
functionCall=FunctionCall(super=BmcModel(__explicitlySet__=[name, arguments])name=object_storage,
arguments=
{"bucket_name": "my_object_store", 
"compartment_ocid": "ocid1.compartment.oc1..xxx",
"storage_tier": "Standard"
}))], 
toolResults=null)

Extrahieren Sie aus der Antwort die action-id, die mit dem Funktionsaufruf verknüpft ist. Diese ID wird im nächsten Schritt zur Ausführung der Aktion verwendet.

String actionId = "<some-action-id>";

Führen Sie die Aktion aus. Die Antwort enthält die letzte Antwort des Agent, die das Ergebnis des Funktionsaufrufs enthält. Beispiel:

String actionId = chatResponse.getChatResult().getRequiredActions().get(0).getActionId();
String functionCallOutput = "{"bucket_name": "test_bucket", "compartment_ocid": "<compartment_OCID>",
"storage_tier":"Standard"}";
 
PerformedAction performedAction = FunctionCallingPerformedAction.builder()
    .actionId(actionId)
    .functionCallOutput(functionCallOutput)
    .build();
 
// Execute the chat session with the performed action
final ChatDetails chatDetails = ChatDetails.builder()
        .shouldStream(shouldStream)
        .userMessage(userMessage)
        .performedActions(List.of(performedAction))
        .sessionId(sessionId)
        .build();
final ChatRequest chatRequest = ChatRequest.builder()
        .chatDetails(chatDetails)
        .agentEndpointId(agentEndpointId)
        .build();
ChatResult chatResult = agentClient.chat(chatRequest);
 
# Chat Result:
# ChatResult(message=The object store 'my_object_store' has been successfully created 
in the specified compartment with the 'Standard' storage tier., 
traces=[], usageDetails=null, toolResults=null)

Oracle Cloud Infrastructure-Dokumentation

Funktionsaufrufe mit SDKs in generativen KI-Agents

Voraussetzungen

Funktionstool erstellen

Mit einem Agenten chatten