Zusammenarbeit mit mehreren Agents

Mehrere Agents erstellen und orchestrieren.

Supervisor-Kollaborator - Multi-Agent

In diesem Beispiel wird gezeigt, wie Sie mehrere Agents erstellen und orchestrieren, die zur Ausführung einer Aufgabe zusammenarbeiten.

Wir haben einen Marketing-Workflow mit drei Agenten:

Ein Trend Analyzer-Mitarbeiter, der Trendschlüsselwörter für ein Thema recherchiert.
Ein Content Writer-Mitarbeiter, der einen Blog mit den Trendschlüsselwörtern schreibt.
Ein Marketing Director-Supervisor-Agent, der die beiden oben genannten Agents orchestriert und das Senden einer E-Mail an den Benutzer verarbeitet.

Der Benutzer interagiert mit dem Marketing Director-Agent (als einzelner Ansprechpartner).

Python

multi_agents.py

import json
from oci.addons.adk import Agent, AgentClient, tool

@tool
def get_trending_keywords(topic):
    """ Get the trending keywords for a given topic. """
    # Here is a mock implementation
    return json.dumps({"topic": topic, "keywords": ["agent", "stargate", "openai"]})

@tool
def send_email(recipient, subject, body):
    """ Send an email to a recipient. """
    # Here is a mock implementation
    print("Sending email to ", recipient, "with subject", subject, "and body", body)
    return "Sent!"

def main():

    # A shared client for all agents
    client = AgentClient(
        auth_type="api_key",
        profile="DEFAULT",
        region="us-chicago-1"
    )

    # trend analyzer collaborator agent
    trend_analyzer = Agent(
        name="Trend Analyzer",
        instructions="You use the tools provided to analyze the trending keywords of given topics.",
        agent_endpoint_id="ocid1.genaiagentendpoint...",
        client=client,
        tools=[
            get_trending_keywords,
        ]
    )

    # content writer collaborator agent
    content_writer = Agent(
        name="Content Writer",
        instructions="You write a mini blog post (4 sentences) using the trending keywords.",
        agent_endpoint_id="ocid1.genaiagentendpoint...",
        client=client,
    )

    # marketing director supervisor agent
    marketing_director = Agent(
        name="Marketing Director",
        instructions="You ask the trend analyzer for trending keywords and "
         + " You then ask the content writer to write a blog post using the trending keywords. "
         + " You then send email to 'jane.doe@example.com' with the blog post."
         + " Then summarize the actions you took and reply to the user.",
        agent_endpoint_id="ocid1.genaiagentendpoint...",
        client=client,
        tools=[
            trend_analyzer.as_tool(
                tool_name="analyze_trending_keywords",
                tool_description="Analyze the trending keywords of given topics",
            ),
            content_writer.as_tool(
                tool_name="write_blog_post",
                tool_description="Write a blog post using the trending keywords.",
            ),
            send_email,
        ]
    )

    # Set up the agents once
    trend_analyzer.setup()
    content_writer.setup()
    marketing_director.setup()

    # Use the supervisor agent to process the end user request
    input = "Produce a blog post about current trends in the AI industry."
    response = marketing_director.run(input, max_steps=5)
    response.pretty_print()


if __name__ == "__main__":
    main()

Die Methode as_tool() ist eine einfache Methode, mit der Sie den Mitarbeiter-Agent als Tool an den Supervisor-Agent übergeben können.

Agent-Objekt direkt an Tools übergeben

Alternativ können Sie das Agent-Objekt direkt an den Parameter tools des Agent-Konstruktors des Supervisor-Agent übergeben.

Python

marketing_director = Agent(
    name="Marketing Director",
    instructions="...",
    agent_endpoint_id="ocid1.genaiagentendpoint...",
    client=client,
    tools=[
        trend_analyzer, # pass the agent object directly
        content_writer, # pass the agent object directly
        send_email,
    ]
)

Dies entspricht dem Aufrufen der Methode as_tool() des Mitarbeiter-Agents, ohne Ihren benutzerdefinierten Toolnamen und Ihre Toolbeschreibung anzugeben. Der ADK verwendet den Namen des Mitarbeiter-Agents als Toolnamen und die Beschreibung des Mitarbeiter-Agents als Toolbeschreibung.

Hinweis: Es wird empfohlen, den Mitarbeiter-Agent mit der Methode as_tool() als Tool an den Supervisor-Agent zu übergeben. Dieser Ansatz gibt Ihnen eine explizite Kontrolle über den Toolnamen und die Toolbeschreibung, die für LLM wichtig sind, um die Tools zu verstehen.

Java

MultiAgentTools.java

package demos.multiagents;

import com.oracle.bmc.adk.tools.Param;
import com.oracle.bmc.adk.tools.Tool;
import com.oracle.bmc.adk.tools.Toolkit;
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.examples.multiagents.tools.MultiAgentTools;
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;
import java.util.List;

public class MultiAgentTools {
    @Tool(name = "get_trending_keywords", description = "Get the trending keywords for a given topic")
    public static String getTrendingKeywords(
          @Param(description = "The topic to get trending keywords for") String topic) {
        return "{\"topic\": \"" + topic + "\", \"keywords\": [\"agent\", \"stargate\", \"openai\"]}";
      }

    @Tool(name = "send_email", description = "Send an email to a recipient")
    public static String sendEmail(
          @Param(description = "The recipient email address") String recipient,
          @Param(description = "The email subject") String subject,
          @Param(description = "The email body content") String body) {
        System.out.println(
            "Sending email to " + recipient + " with subject " + subject + " and body " + body);
        return "Sent!";
      }

  public static void main(String[] args) throws Exception {
    final String TREND_AGENT_ID =
        "ocid1.genaiagentendpoint.oc1.us-chicago-1...";
    final String CONTENT_AGENT_ID =
        "ocid1.genaiagentendpoint.oc1.us-chicago-1...";
    final String MARKET_AGENT_ID =
        "ocid1.genaiagentendpoint.oc1.us-chicago-1...";
    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();

  Method emailMethod =
        MultiAgentTools.class.getMethod("sendEmail", String.class);
    FunctionTool emailTool = new FunctionTool(null, emailMethod);

  Method trendingMethod =
        MultiAgentTools.class.getMethod("getTrendingKeywords", String.class);
    FunctionTool trendingTool = new FunctionTool(null, trendingKeywordsMethod);

    Agent trendAnalyzer = Agent.builder()
            .client(agentClient)
            .agentEndpointId(TREND_AGENT_ID)
            .instructions("You use the tools provided to analyze the trend of topics")
            .tools(Arrays.asList(trendingTool))
            .name("Trend Analyzer")
            .build();

    Agent contentWriter = Agent.builder()
            .client(agentClient)
            .agentEndpointId(TREND_AGENT_ID)
            .instructions("You write a mini blog post (4 sentences) about the trending topics.")
            .tools(null)
            .name("Content Writer")
            .build();

    Agent marketingDirector = Agent.builder()
            .client(agentClient)
            .agentEndpointId(MARKET_AGENT_ID)
            .instructions(
                     "You ask the trend analyzer for trending topics, then ask the content writer "
                + "to write a blog post about them. Finally, send the post via email to j.jing.y.yang@oracle.com "
                + "and summarize the actions taken.",
            )
            .tools(Arrays.asList(
                trendAnalyzer.asTool("analyze_trending_keywords",
                    "Analyze the trending keywords of given topics",
                    5),
                contentWriter.asTool("write_blog_post",
                    "Write a blog post using the trending keywords.",
                    5),
                emailTool))
            .name("Marketing Director")
            .build();

    trendAnalyzer.setup();
    contentWriter.setup();
    marketingDirector.setup();

    String input = "Produce a blog post about current trends in the AI industry.";
    final Integer maxStep = 5;

    final RunOptions runOptions = RunOptions.builder().maxSteps(maxStep).build();
    RunResponse response = marketingDirector.run(input, runOptions);

    response.prettyPrint();
  }
}

Funktionsweise

Wir verwenden das Agent-Muster als Tool, um den hierarchischen Multi-Agent-Workflow zu implementieren.

Der Supervisor-Agent kann die Methode run des Mitwirkenden-Agents als Tool aufrufen.
Der Supervisor-Agent erhält eine Ausführungsantwort vom Mitarbeiter-Agent.
Der Supervisor entscheidet basierend auf der Antwort des Mitarbeiteragenten, was als Nächstes zu tun ist.

Die Methode as_tool() besteht darin, die Methode run() des Mitarbeiter-Agents in ein Funktionstool zu konvertieren, das vom Supervisor-Agent verwendet werden kann.

Orchestrierung mit LLM

Indem wir einen Mitarbeiter-Agent als Tool einsetzen, nutzen wir im Wesentlichen die LLM-Funktionen des Supervisor-Agents, um den Multi-Agent-Workflow zu orchestrieren.

In diesem Beispiel geben wir dem Vorgesetzten viel Flexibilität und Entscheidungsfreiheit, und zwar auf Kosten unserer Fähigkeit, den Workflowfluss genau zu steuern. Informationen zum genauen Steuern des Ablaufs des Workflows mit mehreren Agents finden Sie im Beispiel Deterministischer Workflow.

Oracle Cloud Infrastructure-Dokumentation

Zusammenarbeit mit mehreren Agents

Supervisor-Kollaborator - Multi-Agent

Python

Agent-Objekt direkt an Tools übergeben

Python

Java

Funktionsweise

Orchestrierung mit LLM