Vorhandenen Agent-Schritt hinzufügen

Sie können vorhandene KI-Agenten als Schritte in Ihren Workflow einfügen, um Aufgaben an spezialisierte Agenten zu übertragen. So können Sie Workflows mit mehreren Agenten erstellen, die zwischen verschiedenen Agenten orchestrieren, wobei jeder einen bestimmten Teil eines größeren Prozesses übernimmt.

Hinweis

Führen Sie die folgenden Schritte aus, bevor Sie diese Funktion verwenden:

  • Achten Sie darauf, dass ein Gemini Enterprise-Administrator die Funktion „Workflow Builder“ in den Einstellungen für die Funktionsverwaltung Ihrer App aktiviert hat. Weitere Informationen finden Sie unter Funktionen der Webanwendung verwalten.

  • Achten Sie darauf, dass die Agenten, die Sie hinzufügen möchten, in Ihrer Organisation verfügbar sind. Diese Funktion unterstützt das Hinzufügen der folgenden Agenten:

Vorhandenen Agentenschritt hinzufügen

App

  1. Öffnen Sie die Gemini Enterprise-Webanwendung in einem Browser.
  2. Rufen Sie einen vorhandenen Agenten auf oder erstellen Sie einen neuen Agenten.
  3. Klicken Sie im Flow Builder auf Schritt hinzufügen.
  4. Klicken Sie im Bereich Schritt hinzufügen auf Vorhandene Agenten, um den Bereich zu maximieren.

  5. Sehen Sie sich die Liste der verfügbaren Agenten an.

  6. Klicken Sie auf den Agenten, den Sie hinzufügen möchten.

    Der vorhandene Agentenschritt wird Ihrem Workflow hinzugefügt. Der ausgewählte Agent wird als Teil Ihres Workflows ausgeführt, empfängt Eingaben aus früheren Schritten und gibt Ausgaben an spätere Schritte weiter.

  7. Klicken Sie im Canvas auf den vorhandenen Agentenschritt, um den Konfigurationsbereich zu öffnen, und konfigurieren Sie Folgendes:

    • Prompt: Geben Sie den Prompt oder die Anweisungen ein, mit denen der Agent ausgelöst wird. Sie können statischen Text einfügen oder auf Ausgaben aus vorherigen Schritten verweisen (z. B. ${step_name.output}).

Der Agentenschritt ist ein dynamischer Verweis auf den ausgewählten Agenten. Wenn der Quellagent aktualisiert oder eine neue Version veröffentlicht wird, verwendet Ihr Workflow automatisch die neueste Version.

Weitere Informationen zu den Einschränkungen dieser Funktion finden Sie unter Bekannte Probleme und Einschränkungen.

Funktionsweise von weiterführenden Fragen

Wenn ein vorhandener Agent in einem Workflow ausgeführt wird, kann er die Ausführung pausieren, um dem Nutzer eine weiterführende Frage zu stellen, wenn er fehlende Informationen benötigt, um seine Aufgabe zu erledigen. Weiterführende Fragen werden nativ unterstützt, wenn der referenzierte Agent ein input-required-Signal (A2A) oder ein RequestInput-Ereignis (ADK) ausgibt.

Wenn ein vorhandener Agentenschritt ausgeführt wird und zusätzliche Informationen erforderlich sind, geschieht Folgendes:

  1. Ausführung wird pausiert: Die Ausführung des Workflows wird beim vorhandenen Agenten schritt pausiert und ein Human-in-the-Loop-Prompt (HITL) wird initiiert.
  2. Nutzer beantwortet den Prompt: In der Gemini Enterprise-Webanwendung wird dem Nutzer die weiterführende Frage des Agenten zusammen mit einem Textfeld zur Eingabe seiner Antwort angezeigt.
  3. Ausführung wird fortgesetzt: Wenn der Nutzer seine Antwort sendet, wird der Workflow mit dem vorhandenen Agenten fortgesetzt und die Antwort des Nutzers wird an den Agenten zurückgegeben.
  4. Unterstützung für mehrere Runden: Der Agent kann in mehreren Runden nacheinander mehrere weiterführende Fragen stellen, bis er alle erforderlichen Informationen gesammelt hat und die endgültige Ausgabe erstellt.

Kontextisolation

Während des Austauschs von weiterführenden Fragen erhält der referenzierte Agent nur seinen eigenen Interaktionsverlauf mit dem Nutzer und den für den Knoten konfigurierten ursprünglichen Prompt. Ausgaben und Variablen aus anderen Schritten im Workflow werden nicht automatisch an den referenzierten Agenten übergeben, es sei denn, sie werden explizit im Prompt des Schritts referenziert.

Weiterführende Fragen in Ihrem Agenten implementieren

Wenn Sie weiterführende Fragen unterstützen möchten, konfigurieren Sie Ihren benutzerdefinierten Agenten so, dass er ein Request-Input-Signal auf Protokollebene ausgibt, wenn er zusätzliche Informationen benötigt.

A2A-Agenten (nativ)

Für Agenten, die das Agent-to-Agent-Protokoll (A2A) direkt implementieren, geben Sie die Aufgabe mit TaskUpdater im Status input-required zurück und geben Sie die weiterführende Frage in der Nachrichtennutzlast an:

from a2a.server.tasks import TaskUpdater
from a2a.types import Message, Part, Role, TextPart

# Inside your custom agent's task executor class:
async def execute(self, context, event_queue):
    updater = TaskUpdater(event_queue, context.task_id, context.context_id)
    if context.current_task is None:
        await updater.submit()
    await updater.start_work()

    user_input = context.get_user_input()
    if "weather" in user_input and "tokyo" not in user_input.lower():
        await updater.requires_input(
            Message(
                message_id=f"q-{context.task_id}",
                role=Role.agent,
                parts=[Part(root=TextPart(
                    text="Which city would you like the weather for?"))],
                task_id=context.task_id,
                context_id=context.context_id,
            )
        )
        return

    await updater.complete(
        Message(
            message_id=f"a-{context.task_id}",
            role=Role.agent,
            parts=[Part(root=TextPart(
                text="It is sunny and 72°F in Tokyo."))],
            task_id=context.task_id,
            context_id=context.context_id,
        )
    )

Die Antwort des Nutzers wird als message/send-Anfrage mit derselben taskId an Ihren Agenten zurückgesendet.

A2A-Agenten (mit ADK erstellt)

Wenn Ihr Agent mit dem Agent Development Kit (ADK) erstellt und über A2A verfügbar gemacht wurde (mit to_a2a()), umschließen Sie die Funktion zum Stellen von Fragen mit LongRunningFunctionTool:

from google.adk.agents import Agent
from google.adk.tools.long_running_tool import LongRunningFunctionTool
from google.adk.a2a.utils.agent_to_a2a import to_a2a

def get_weather(city: str) -> str:
    """Returns weather information for a city."""
    return f"It is sunny and 72°F in {city}."

def ask_clarifying_question(question: str) -> None:
    """Asks the user a question and waits for their reply."""
    return None

root_agent = Agent(
    model="gemini-2.5-flash",
    name="weather_agent",
    instruction=(
        "If the user asks for weather without specifying a city, call "
        "`ask_clarifying_question` and wait. Do not guess."
    ),
    tools=[get_weather, LongRunningFunctionTool(ask_clarifying_question)],
)

a2a_app = to_a2a(root_agent, port=8000)

ADK-Agenten in der Agent Engine

Für ADK-Agenten, die in der Reasoning Engine in der Agent Engine gehostet werden, geben Sie ein RequestInput-Ereignis in einem Generator-Tool oder einem benutzerdefinierten Agentenschritt aus:

from google.adk.events import RequestInput

# Inside a generator tool or custom agent step
def ask_for_details():
    """Requests user input during tool or step execution."""
    yield RequestInput(
        interrupt_id="weather_city",
        message="Which city would you like the weather for?",
    )

Nächste Schritte

  • Informationen zum Konfigurieren von Agentenknoten-Connectors und -Aktionen .
  • Informationen zum Verbinden von MCP-Servern .
  • Informationen zum Verwenden von Schritten zur Flow-Steuerung .