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

Bevor Sie diese Funktion verwenden, führen Sie die folgenden Schritte aus:

  • Achten Sie darauf, dass ein Gemini Enterprise-Administrator die Funktion „Workflow Builder“ in den Einstellungen zur 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 Agent-Schritt hinzufügen

App

  1. Öffnen Sie die Gemini Enterprise-Webanwendung in einem Browser.
  2. Rufen Sie einen vorhandenen Agent auf oder erstellen Sie einen neuen.
  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 Agent, den Sie hinzufügen möchten.

    Der vorhandene Agent-Schritt wird Ihrem Workflow hinzugefügt. Der ausgewählte Agent wird als Teil Ihres Workflows ausgeführt, wobei er Eingaben aus früheren Schritten erhält und Ausgaben an spätere Schritte weiterleitet.

  7. Klicken Sie im Canvas auf den vorhandenen Agent-Schritt, 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 Agent-Schritt ist ein dynamischer Verweis auf den ausgewählten Agent. Wenn der Quell-Agent 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 klärenden Fragen

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

Wenn ein vorhandener Agent-Schritt ausgeführt wird und zusätzliche Informationen erforderlich sind:

  1. Ausführung wird pausiert: Der Workflow pausiert die Ausführung beim vorhandenen Agent Schritt und initiiert einen HITL-Prompt (Human-in-the-Loop).
  2. Nutzer beantwortet den Prompt: In der Gemini Enterprise-Webanwendung wird dem Nutzer die klärende 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 Agent fortgesetzt und die Antwort des Nutzers an den Agent zurückgegeben.
  4. Unterstützung für mehrere Unterhaltungsrunden: Der Agent kann in mehreren Unterhaltungsrunden nacheinander mehrere klärende Fragen stellen, bis er alle erforderlichen Informationen gesammelt hat und die endgültige Ausgabe erstellt.

Kontextisolation

Während des Austauschs von klärenden 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 Agent weitergegeben, es sei denn, sie werden explizit im Prompt des Schritts referenziert.

Klärende Fragen in Ihrem Agent implementieren

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

A2A-Agenten (nativ)

Bei 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 klärende 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 Agent 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

Bei 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 Agent-Schritt 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 zur Verwendung von Connector-Aktionen .
  • Informationen zum Verbinden von MCP-Servern .
  • Informationen zur Verwendung von Schritten zur Ablaufsteuerung .