Flujo de trabajo determinista

Descubra cómo crear un flujo de trabajo determinista de varios pasos con los agentes.

Ejemplo de flujo de trabajo en varios pasos

En este ejemplo se muestra cómo crear un flujo de trabajo determinista con pasos agénticos, combinando el flujo de control nativo y un marco de agente "Razonamiento y actuación" (ReAct).

A diferencia de los flujos de trabajo de agentes totalmente autónomos, un flujo de trabajo determinista te da control sobre la secuencia de pasos mientras aprovechas el poder de los agentes para tareas específicas.

Python

varios pasos-workflow.py

from oci.addons.adk import Agent, AgentClient
from custom_functon_tools import ResearcherToolkit, WriterToolkit

"""
This examples shows how you can build "deterministically orchestrated workflows with agentic steps".
"""

# Your (existing) vanilla python code to be integrated into this agentic workflow
def get_user_preferences():
    # Simulate result you fetched from a DB
    return {
        "email": "your@email.com",
        "style": ["casual", "humorous"],
        "topics": ["ai"]
    }

def main():

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

    researcher = Agent(
        client=client,
        agent_endpoint_id="ocid1.genaiagentendpoint...",
        name="Researcher",
        instructions="You are a researcher. You research trending keywords based on the user preferences.",
        tools=[ResearcherToolkit()]
    )

    writer = Agent(
        client=client,
        agent_endpoint_id="ocid1.genaiagentendpoint...",
        name="Writer",
        instructions="You are a writer. You write a blog post based on the trending keywords and the user preferences.",
        tools=[WriterToolkit()]
    )

    researcher.setup()
    writer.setup()

    # Step 1: Fetch user preferences or any pre-processing information. (non-agentic step)
    user_preferences = get_user_preferences()

    # Step 2: Research trending keywords using outputs from the previous steps as input. (agentic step)
    topics = user_preferences['topics']
    researcher_prompt = f"Research trending keywords for the following topics: {topics}"
    last_run_response = researcher.run(researcher_prompt)

    # Step 3: Write a blog post using outputs from last two steps as input. (agentic step) 
    keywords = last_run_response.output
    style = user_preferences['style']
    email = user_preferences['email']
    writer_prompt = f"Write a 5 sentences blog post and email it to {email}. Use style: {style}. Blog post should be based on: {keywords}."
    last_run_response = writer.run(writer_prompt)

    # Step 4: Do whatever you want with the last step output. Here we just print it.
    last_run_response.pretty_print()

if __name__ == "__main__":
    main()

Java

AgenticWorkflowDemo.java


package demos.determinsticWorkflow;

import com.oracle.bmc.ConfigFileReader;
import com.oracle.bmc.adk.client.AgentClient;
import com.oracle.bmc.adk.run.RunResponse;
import com.oracle.bmc.auth.BasicAuthenticationDetailsProvider;
import com.oracle.bmc.auth.SessionTokenAuthenticationDetailsProvider;
import com.oracle.bmc.adk.agent.Agent;
import com.oracle.bmc.adk.agent.RunOptions;
import com.oracle.bmc.adk.examples.determinsticWorkflow.tools.ResearcherToolkit;
import com.oracle.bmc.adk.examples.determinsticWorkflow.tools.WriterToolkit;

import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class AgenticWorkflowDemo {

  public static void main(String[] args) throws IOException {
    // Configuration parameters
    final String configLocation = "~/.oci/config";
    final String configProfile = "DEFAULT";
    final String researchAgentEndpointId =
        "ocid1.genaiagentendpoint...";
    final String writerAgentEndpointId =
        "ocid1.genaiagentendpoint...";

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

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

    // Create researcher agent with its toolkit
    Agent researcher = Agent.builder()
            .client(client)
            .agentEndpointId(researchAgentEndpointId)
            .instructions(
                "You are a researcher. You research trending keywords based on the user preferences.")
            .tools(Arrays.asList(new ResearcherToolkit()))
            .name("Researcher")
            .build();

    // Create writer agent with its toolkit
    Agent writer = Agent.builder()
            .client(client)
            .agentEndpointId(writerAgentEndpointId)
            .instructions(
                "You are a writer. You write a blog post based on the trending keywords and the user preferences.")
            .tools(Arrays.asList(new WriterToolkit()))
            .name("Writer")
            .build();

    // Set up both agents
    researcher.setup();
    writer.setup();

    // Step 1: fetch user preferences (a non-agentic step)
    Map<String, Object> userPreferences = getUserPreferences();

    // Step 2: research trending keywords (agentic step)
    List<String> topics = (List<String>) userPreferences.get("topics");
    String researcherPrompt = "Research trending keywords for the following topics: " + topics;
    final Integer maxSteps = 3;
    RunOptions runOptions = RunOptions.builder().maxSteps(maxSteps).build();
    RunResponse researcherResponse = researcher.run(researcherPrompt, runOptions);
    String keywords = researcherResponse.getOutput();

    // Step 3: write a blog post (agentic step)
    List<String> style = (List<String>) userPreferences.get("style");
    String email = (String) userPreferences.get("delivery_email");
    String writerPrompt =
        "Write a 5 sentences blog post and email it to "
            + email
            + ". Use style: "
            + style
            + ". Blog post should be based on: "
            + keywords;
    RunResponse writerResponse = writer.run(writerPrompt, runOptions);

    // Step 4: print the final output
    writerResponse.prettyPrint();
  }

  // Simulate fetching user preferences (for example, from a database)
  private static Map<String, Object> getUserPreferences() {
    Map<String, Object> preferences = new HashMap<>();
    preferences.put("delivery_email", "j.jing.y.yang@oracle.com");
    preferences.put("style", Arrays.asList("casual", "humorous"));
    preferences.put("topics", Arrays.asList("ai"));
    return preferences;
  }
}

Herramientas de función personalizadas

En este ejemplo se utilizan kits de herramientas personalizados para los agentes de investigador y escritor. Aquí hay una versión simplificada de cómo se verían:

Python

custom_functon_tools.py

from typing import Dict, List
from oci.addons.adk import tool, Toolkit

@tool
def get_trending_keywords(topic: str) -> Dict[str, List[str]]:
    """Get trending keywords for a given topic"""
    # In a real implementation, this might call an API or database.
    if topic == "ai":
        return {"topic": topic, "keywords": ["generative AI", "multi-agent systems", "LLM agents"]}
    return {"topic": topic, "keywords": ["unknown"]}

@tool
def send_email(recipient: str, subject: str, body: str) -> str:
    """Send an email with the given subject and body to the recipient"""
    # In a real implementation, this would send an actual email.
    print(f"Sending email to {recipient}")
    print(f"Subject: {subject}")
    print(f"Body: {body}")
    return "Email sent successfully"

class ResearcherToolkit(Toolkit):
    """Toolkit for researching trending topics"""

    def __init__(self):
        super().__init__(name="ResearcherToolkit", description="Tools for researching trending topics")
        self.add_tool(get_trending_keywords)

class WriterToolkit(Toolkit):
    """Toolkit for writing content and sending emails"""

    def __init__(self):
        super().__init__(name="WriterToolkit", description="Tools for writing content and sending emails")
        self.add_tool(send_email)

Java

MultiAgentTools.java

package demos.tools;

import com.oracle.bmc.adk.tools.Param;
import com.oracle.bmc.adk.tools.Tool;
import com.oracle.bmc.adk.tools.Toolkit;

public class MultiAgentTools extends Toolkit {
  @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!";
  }

}

Cuándo utilizar este patrón

Este patrón resulta especialmente útil cuando:

  • Necesita una ejecución predecible y repetible.
  • Partes de su flujo de trabajo dependen de sistemas o bases de datos existentes.
  • Debe controlar exactamente cuándo y cómo se llaman los agentes.
  • La lógica de negocio exige secuencias específicas que no deben dejarse a la toma de decisiones de los agentes.