Collaborazione con più agenti

Creazione e orchestrazione di più agenti.

Supervisore-Collaboratore - Multiagente

In questo esempio viene illustrato come creare e orchestrare più agenti che collaborano per eseguire un task.

Abbiamo un flusso di lavoro di marketing con tre agenti:

Agente collaboratore di Trend Analyzer che esegue ricerche sulle parole chiave di tendenza specificate in un argomento.
Agente collaboratore di Content Writer che scrive un blog utilizzando le parole chiave di tendenza.
Agente supervisore Marketing Director che gestisce l'invio di un messaggio di posta elettronica all'utente.

L'utente interagisce con l'agente Marketing Director (come singolo punto di contatto).

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

Il metodo as_tool() è un metodo pratico che consente di passare l'agente collaboratore come strumento all'agente supervisore.

Passaggio dell'oggetto agente direttamente agli strumenti

In alternativa, è possibile passare l'oggetto agente direttamente al parametro tools del costruttore Agent dell'agente supervisore.

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,
    ]
)

Ciò equivale a richiamare il metodo as_tool() dell'agente collaboratore senza specificare il nome e la descrizione dello strumento personalizzati. ADK utilizza il nome dell'agente collaboratore come nome dello strumento e la descrizione dell'agente collaboratore come descrizione dello strumento.

Nota: si consiglia di utilizzare il metodo as_tool() per passare l'agente collaboratore come strumento all'agente supervisore. Questo approccio ti dà un controllo più esplicito sul nome dello strumento e sulla descrizione dello strumento che sono importanti per LLM per comprendere gli strumenti.

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

Funzionamento

Stiamo utilizzando il pattern agente come strumento per implementare il workflow multiagente gerarchico.

L'agente supervisore può richiamare il metodo run dell'agente collaboratore come strumento.
L'agente supervisore riceve la risposta di esecuzione dall'agente collaboratore.
Il supervisore decide cosa fare in seguito in base alla risposta dell'agente collaboratore.

Il metodo as_tool() consiste nel convertire il metodo run() dell'agente collaboratore in uno strumento di funzione che può essere utilizzato dall'agente supervisore.

Orchestrazione mediante LLM

Rendendo un agente collaboratore uno strumento, essenzialmente utilizziamo lo strumento LLM dell'agente supervisore per orchestrare il flusso di lavoro multi-agente.

In questo esempio, stiamo offrendo al supervisore molta flessibilità e agenzia, al costo di rinunciare alla nostra capacità di controllare con precisione il flusso del flusso di lavoro. Per controllare con precisione il flusso del flusso di lavoro multiagente, vedere l'esempio Workflow deterministico.

Documentazione dell'infrastruttura Oracle Cloud

Collaborazione con più agenti

Supervisore-Collaboratore - Multiagente

Python

Passaggio dell'oggetto agente direttamente agli strumenti

Python

Java

Funzionamento

Orchestrazione mediante LLM