Agentes secuenciales¶
Supported in ADKPython v0.1.0Typescript v0.2.0Go v0.1.0Java v0.2.0
El SequentialAgent es un agente de flujo de trabajo que ejecuta sus sub-agentes en el orden en que están especificados en la lista.
Usa el SequentialAgent cuando quieras que la ejecución ocurra en un orden fijo y estricto.
Ejemplo¶
- Quieres construir un agente que pueda resumir cualquier página web, usando dos herramientas:
Get Page ContentsySummarize Page. Dado que el agente siempre debe llamar aGet Page Contentsantes de llamar aSummarize Page(¡no puedes resumir de la nada!), debes construir tu agente usando unSequentialAgent.
Al igual que otros agentes de flujo de trabajo, el SequentialAgent no está impulsado por un LLM, y por lo tanto es determinista en cómo se ejecuta. Dicho esto, los agentes de flujo de trabajo se preocupan solo por su ejecución (es decir, en secuencia), y no por su lógica interna; las herramientas o sub-agentes de un agente de flujo de trabajo pueden o no utilizar LLMs.
Cómo funciona¶
Cuando se llama al método Run Async del SequentialAgent, realiza las siguientes acciones:
- Iteración: Itera a través de la lista de sub-agentes en el orden en que fueron proporcionados.
- Ejecución de Sub-Agentes: Para cada sub-agente en la lista, llama al método
Run Asyncdel sub-agente.
Ejemplo Completo: Pipeline de Desarrollo de Código¶
Considera un pipeline simplificado de desarrollo de código:
- Code Writer Agent: Un Agente LLM que genera código inicial basado en una especificación.
- Code Reviewer Agent: Un Agente LLM que revisa el código generado en busca de errores, problemas de estilo y adherencia a las mejores prácticas. Recibe la salida del Code Writer Agent.
- Code Refactorer Agent: Un Agente LLM que toma el código revisado (y los comentarios del revisor) y lo refactoriza para mejorar la calidad y abordar problemas.
Un SequentialAgent es perfecto para esto:
Esto asegura que el código se escriba, luego se revise, y finalmente se refactorice, en un orden estricto y confiable. La salida de cada sub-agente se pasa al siguiente almacenándola en el estado a través de Output Key.
Contexto de Invocación Compartido
El SequentialAgent pasa el mismo InvocationContext a cada uno de sus sub-agentes. Esto significa que todos comparten el mismo estado de sesión, incluyendo el espacio de nombres temporal (temp:), facilitando el paso de datos entre pasos dentro de un solo turno.
Code
from google.adk.agents.sequential_agent import SequentialAgent
from google.adk.agents.llm_agent import LlmAgent
# --- Constants ---
GEMINI_MODEL = "gemini-2.5-flash"
# --- 1. Define Sub-Agents for Each Pipeline Stage ---
# Code Writer Agent
# Takes the initial specification (from user query) and writes code.
code_writer_agent = LlmAgent(
name="CodeWriterAgent",
model=GEMINI_MODEL,
instruction="""
You are a Python Code Generator.
Based *only* on the user's request, write Python code that fulfills the requirement.
Output *only* the complete Python code block, enclosed in triple backticks (```python ... ```).
Do not add any other text before or after the code block.
""",
description="Writes initial Python code based on a specification.",
output_key="generated_code"
)
# Code Reviewer Agent
# Takes the code generated by the previous agent (read from state) and provides feedback.
code_reviewer_agent = LlmAgent(
name="CodeReviewerAgent",
model=GEMINI_MODEL,
instruction="""
You are an expert Python Code Reviewer.
Your task is to provide constructive feedback on the provided code.
**Code to Review:**
```python
{generated_code}
```
**Review Criteria:**
1. **Correctness:** Does the code work as intended? Are there logic errors?
2. **Readability:** Is the code clear and easy to understand? Follows PEP 8 style guidelines?
3. **Efficiency:** Is the code reasonably efficient? Any obvious performance bottlenecks?
4. **Edge Cases:** Does the code handle potential edge cases or invalid inputs gracefully?
5. **Best Practices:** Does the code follow common Python best practices?
**Output:**
Provide your feedback as a concise, bulleted list. Focus on the most important points for improvement.
If the code is excellent and requires no changes, simply state: "No major issues found."
Output *only* the review comments or the "No major issues" statement.
""",
description="Reviews code and provides feedback.",
output_key="review_comments"
)
# Code Refactorer Agent
# Takes the original code and the review comments (read from state) and refactors the code.
code_refactorer_agent = LlmAgent(
name="CodeRefactorerAgent",
model=GEMINI_MODEL,
instruction="""
You are a Python Code Refactoring AI.
Your goal is to improve the given Python code based on the provided review comments.
**Original Code:**
```python
{generated_code}
```
**Review Comments:**
{review_comments}
**Task:**
Carefully apply the suggestions from the review comments to refactor the original code.
If the review comments state "No major issues found," return the original code unchanged.
Ensure the final code is complete, functional, and includes necessary imports and docstrings.
**Output:**
Output *only* the final, refactored Python code block, enclosed in triple backticks (```python ... ```).
Do not add any other text before or after the code block.
""",
description="Refactors code based on review comments.",
output_key="refactored_code"
)
# --- 2. Create the SequentialAgent ---
# This agent orchestrates the pipeline by running the sub_agents in order.
code_pipeline_agent = SequentialAgent(
name="CodePipelineAgent",
sub_agents=[code_writer_agent, code_reviewer_agent, code_refactorer_agent],
description="Executes a sequence of code writing, reviewing, and refactoring.",
)
root_agent = code_pipeline_agent
// Part of agent.ts --> Follow https://google.github.io/adk-docs/get-started/quickstart/ to learn the setup
// --- 1. Define Sub-Agents for Each Pipeline Stage ---
// Code Writer Agent
// Takes the initial specification (from user query) and writes code.
const codeWriterAgent = new LlmAgent({
name: "CodeWriterAgent",
model: GEMINI_MODEL,
instruction: `You are a Python Code Generator.
Based *only* on the user's request, write Python code that fulfills the requirement.
Output *only* the complete Python code block, enclosed in triple backticks (\`\`\`python ... \`\`\`).
Do not add any other text before or after the code block.
`,
description: "Writes initial Python code based on a specification.",
outputKey: "generated_code" // Stores output in state['generated_code']
});
// Code Reviewer Agent
// Takes the code generated by the previous agent (read from state) and provides feedback.
const codeReviewerAgent = new LlmAgent({
name: "CodeReviewerAgent",
model: GEMINI_MODEL,
instruction: `You are an expert Python Code Reviewer.
Your task is to provide constructive feedback on the provided code.
**Code to Review:**
\`\`\`python
{generated_code}
\`\`\`
**Review Criteria:**
1. **Correctness:** Does the code work as intended? Are there logic errors?
2. **Readability:** Is the code clear and easy to understand? Follows PEP 8 style guidelines?
3. **Efficiency:** Is the code reasonably efficient? Any obvious performance bottlenecks?
4. **Edge Cases:** Does the code handle potential edge cases or invalid inputs gracefully?
5. **Best Practices:** Does the code follow common Python best practices?
**Output:**
Provide your feedback as a concise, bulleted list. Focus on the most important points for improvement.
If the code is excellent and requires no changes, simply state: "No major issues found."
Output *only* the review comments or the "No major issues" statement.
`,
description: "Reviews code and provides feedback.",
outputKey: "review_comments", // Stores output in state['review_comments']
});
// Code Refactorer Agent
// Takes the original code and the review comments (read from state) and refactors the code.
const codeRefactorerAgent = new LlmAgent({
name: "CodeRefactorerAgent",
model: GEMINI_MODEL,
instruction: `You are a Python Code Refactoring AI.
Your goal is to improve the given Python code based on the provided review comments.
**Original Code:**
\`\`\`python
{generated_code}
\`\`\`
**Review Comments:**
{review_comments}
**Task:**
Carefully apply the suggestions from the review comments to refactor the original code.
If the review comments state "No major issues found," return the original code unchanged.
Ensure the final code is complete, functional, and includes necessary imports and docstrings.
**Output:**
Output *only* the final, refactored Python code block, enclosed in triple backticks (\`\`\`python ... \`\`\`).
Do not add any other text before or after the code block.
`,
description: "Refactors code based on review comments.",
outputKey: "refactored_code", // Stores output in state['refactored_code']
});
// --- 2. Create the SequentialAgent ---
// This agent orchestrates the pipeline by running the sub_agents in order.
const rootAgent = new SequentialAgent({
name: "CodePipelineAgent",
subAgents: [codeWriterAgent, codeReviewerAgent, codeRefactorerAgent],
description: "Executes a sequence of code writing, reviewing, and refactoring.",
// The agents will run in the order provided: Writer -> Reviewer -> Refactorer
});
model, err := gemini.NewModel(ctx, modelName, &genai.ClientConfig{})
if err != nil {
return fmt.Errorf("failed to create model: %v", err)
}
codeWriterAgent, err := llmagent.New(llmagent.Config{
Name: "CodeWriterAgent",
Model: model,
Description: "Writes initial Go code based on a specification.",
Instruction: `You are a Go Code Generator.
Based *only* on the user's request, write Go code that fulfills the requirement.
Output *only* the complete Go code block, enclosed in triple backticks ('''go ... ''').
Do not add any other text before or after the code block.`,
OutputKey: "generated_code",
})
if err != nil {
return fmt.Errorf("failed to create code writer agent: %v", err)
}
codeReviewerAgent, err := llmagent.New(llmagent.Config{
Name: "CodeReviewerAgent",
Model: model,
Description: "Reviews code and provides feedback.",
Instruction: `You are an expert Go Code Reviewer.
Your task is to provide constructive feedback on the provided code.
**Code to Review:**
'''go
{generated_code}
'''
**Review Criteria:**
1. **Correctness:** Does the code work as intended? Are there logic errors?
2. **Readability:** Is the code clear and easy to understand? Follows Go style guidelines?
3. **Idiomatic Go:** Does the code use Go's features in a natural and standard way?
4. **Edge Cases:** Does the code handle potential edge cases or invalid inputs gracefully?
5. **Best Practices:** Does the code follow common Go best practices?
**Output:**
Provide your feedback as a concise, bulleted list. Focus on the most important points for improvement.
If the code is excellent and requires no changes, simply state: "No major issues found."
Output *only* the review comments or the "No major issues" statement.`,
OutputKey: "review_comments",
})
if err != nil {
return fmt.Errorf("failed to create code reviewer agent: %v", err)
}
codeRefactorerAgent, err := llmagent.New(llmagent.Config{
Name: "CodeRefactorerAgent",
Model: model,
Description: "Refactors code based on review comments.",
Instruction: `You are a Go Code Refactoring AI.
Your goal is to improve the given Go code based on the provided review comments.
**Original Code:**
'''go
{generated_code}
'''
**Review Comments:**
{review_comments}
**Task:**
Carefully apply the suggestions from the review comments to refactor the original code.
If the review comments state "No major issues found," return the original code unchanged.
Ensure the final code is complete, functional, and includes necessary imports.
**Output:**
Output *only* the final, refactored Go code block, enclosed in triple backticks ('''go ... ''').
Do not add any other text before or after the code block.`,
OutputKey: "refactored_code",
})
if err != nil {
return fmt.Errorf("failed to create code refactorer agent: %v", err)
}
codePipelineAgent, err := sequentialagent.New(sequentialagent.Config{
AgentConfig: agent.Config{
Name: appName,
Description: "Executes a sequence of code writing, reviewing, and refactoring.",
SubAgents: []agent.Agent{
codeWriterAgent,
codeReviewerAgent,
codeRefactorerAgent,
},
},
})
if err != nil {
return fmt.Errorf("failed to create sequential agent: %v", err)
}
import com.google.adk.agents.LlmAgent;
import com.google.adk.agents.SequentialAgent;
import com.google.adk.events.Event;
import com.google.adk.runner.InMemoryRunner;
import com.google.adk.sessions.Session;
import com.google.genai.types.Content;
import com.google.genai.types.Part;
import io.reactivex.rxjava3.core.Flowable;
public class SequentialAgentExample {
private static final String APP_NAME = "CodePipelineAgent";
private static final String USER_ID = "test_user_456";
private static final String MODEL_NAME = "gemini-2.0-flash";
public static void main(String[] args) {
SequentialAgentExample sequentialAgentExample = new SequentialAgentExample();
sequentialAgentExample.runAgent(
"Write a Java function to calculate the factorial of a number.");
}
public void runAgent(String prompt) {
LlmAgent codeWriterAgent =
LlmAgent.builder()
.model(MODEL_NAME)
.name("CodeWriterAgent")
.description("Writes initial Java code based on a specification.")
.instruction(
"""
You are a Java Code Generator.
Based *only* on the user's request, write Java code that fulfills the requirement.
Output *only* the complete Java code block, enclosed in triple backticks (```java ... ```).
Do not add any other text before or after the code block.
""")
.outputKey("generated_code")
.build();
LlmAgent codeReviewerAgent =
LlmAgent.builder()
.model(MODEL_NAME)
.name("CodeReviewerAgent")
.description("Reviews code and provides feedback.")
.instruction(
"""
You are an expert Java Code Reviewer.
Your task is to provide constructive feedback on the provided code.
**Code to Review:**
```java
{generated_code}
```
**Review Criteria:**
1. **Correctness:** Does the code work as intended? Are there logic errors?
2. **Readability:** Is the code clear and easy to understand? Follows Java style guidelines?
3. **Efficiency:** Is the code reasonably efficient? Any obvious performance bottlenecks?
4. **Edge Cases:** Does the code handle potential edge cases or invalid inputs gracefully?
5. **Best Practices:** Does the code follow common Java best practices?
**Output:**
Provide your feedback as a concise, bulleted list. Focus on the most important points for improvement.
If the code is excellent and requires no changes, simply state: "No major issues found."
Output *only* the review comments or the "No major issues" statement.
""")
.outputKey("review_comments")
.build();
LlmAgent codeRefactorerAgent =
LlmAgent.builder()
.model(MODEL_NAME)
.name("CodeRefactorerAgent")
.description("Refactors code based on review comments.")
.instruction(
"""
You are a Java Code Refactoring AI.
Your goal is to improve the given Java code based on the provided review comments.
**Original Code:**
```java
{generated_code}
```
**Review Comments:**
{review_comments}
**Task:**
Carefully apply the suggestions from the review comments to refactor the original code.
If the review comments state "No major issues found," return the original code unchanged.
Ensure the final code is complete, functional, and includes necessary imports and docstrings.
**Output:**
Output *only* the final, refactored Java code block, enclosed in triple backticks (```java ... ```).
Do not add any other text before or after the code block.
""")
.outputKey("refactored_code")
.build();
SequentialAgent codePipelineAgent =
SequentialAgent.builder()
.name(APP_NAME)
.description("Executes a sequence of code writing, reviewing, and refactoring.")
// The agents will run in the order provided: Writer -> Reviewer -> Refactorer
.subAgents(codeWriterAgent, codeReviewerAgent, codeRefactorerAgent)
.build();
// Create an InMemoryRunner
InMemoryRunner runner = new InMemoryRunner(codePipelineAgent, APP_NAME);
// InMemoryRunner automatically creates a session service. Create a session using the service
Session session = runner.sessionService().createSession(APP_NAME, USER_ID).blockingGet();
Content userMessage = Content.fromParts(Part.fromText(prompt));
// Run the agent
Flowable<Event> eventStream = runner.runAsync(USER_ID, session.id(), userMessage);
// Stream event response
eventStream.blockingForEach(
event -> {
if (event.finalResponse()) {
System.out.println(event.stringifyContent());
}
});
}
}