1. Einführung
Google Workspace – hier wird gearbeitet. Von der Erstellung von Berichten in Google Docs über die Datenanalyse in Google Tabellen bis hin zur Zusammenarbeit in Gmail und Google Meet.
Stellen Sie sich vor, Ihre Dokumente, Tabellen und Gmail wären nicht nur Tools, sondern Mitarbeiter.
Mithilfe des Agent Development Kit (ADK) von Google und der Agent Engine von Vertex AI ist das nicht mehr nur eine Idee. Wir werden diese Frameworks nutzen, um einen intelligenten Agent zu erstellen, ihn in großem Maßstab bereitzustellen und nahtlos in unsere Google Workspace-Tools zu integrieren. So können wir eine neue Ära der Agent-basierten Produktivität einläuten.
In diesem Codelab gehen Sie schrittweise vor:
- Entwickeln Sie den KI-Faktenprüfer-Agenten mit dem Agent Development Kit.
- Stellen Sie den Agent in Agent Engine bereit, einer vollständig verwalteten Umgebung zum Ausführen von Agents im großen Maßstab.
- Binden Sie diesen Agent in Google Docs ein, um Fakten für den Text im Dokument zu prüfen.
Ein konzeptionelles Diagramm, das die Funktionsweise der endgültigen Lösung veranschaulicht, ist unten zu sehen:
Hier sehen Sie die endgültige Ausgabe des Faktencheck-Agents in einem Google-Dokument. Der Originaltext enthält einige Aussagen, die jeweils auf ihren Wahrheitsgehalt geprüft werden. Die Ausgabegrenze im Feld mit der roten Ecke ist die Ausgabe des Agenten.
Aufgaben
- Entwerfen, erstellen und stellen Sie einen Agent bereit, der Fakten in einem Google-Dokument überprüft.
Lerninhalte
- Agent mit dem Agent Development Kit (ADK) entwickeln
- Testen Sie den Agent lokal und stellen Sie ihn in Agent Engine bereit.
- Integrieren Sie den Agent in ein Google Workspace-Dokument (Google-Dokument).
Voraussetzungen
- Chrome-Webbrowser
- Ein Gmail-Konto
- Ein Cloud-Projekt mit aktivierter Abrechnung
In diesem Codelab, das für Entwickler aller Erfahrungsstufen (auch Anfänger) konzipiert ist, werden Python und Apps Script im Beispielcode verwendet. Kenntnisse dieser Programmiersprachen sind jedoch keine Voraussetzung. Grundlegende Kenntnisse im Lesen von Code reichen aus, um die vorgestellten Konzepte zu verstehen.
2. Hinweis
Projekt erstellen
- Wählen Sie in der Google Cloud Console auf der Seite zur Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.
- Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist .
- Sie verwenden Cloud Shell, eine Befehlszeilenumgebung, die in Google Cloud ausgeführt wird und in der „bq“ vorinstalliert ist. Klicken Sie oben in der Google Cloud Console auf „Cloud Shell aktivieren“.
- Wenn Sie mit Cloud Shell verbunden sind, können Sie mit dem folgenden Befehl prüfen, ob Sie bereits authentifiziert sind und das Projekt auf Ihre Projekt-ID festgelegt ist:
gcloud auth list
- Führen Sie den folgenden Befehl in Cloud Shell aus, um zu bestätigen, dass der gcloud-Befehl Ihr Projekt kennt.
gcloud config list project
- Wenn Ihr Projekt nicht festgelegt ist, verwenden Sie den folgenden Befehl, um es festzulegen:
gcloud config set project <YOUR_PROJECT_ID>
- Aktivieren Sie die erforderlichen APIs mit dem unten gezeigten Befehl. Dies kann einige Minuten dauern.
gcloud services enable cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
aiplatform.googleapis.com \
discoveryengine.googleapis.com
Bei erfolgreicher Ausführung des Befehls sollte eine Meldung wie die unten gezeigte angezeigt werden:
Operation "operations/..." finished successfully.
Wenn eine API fehlt, können Sie sie jederzeit während der Implementierung aktivieren.
Informationen zu gcloud-Befehlen und deren Verwendung finden Sie in der Dokumentation.
3. ADK-Agent erstellen
Wir erstellen den ADK-Agenten (Document Fact Checker Agent), einen KI-basierten Auditor, der Text auf Fakten überprüft. Er ist von der benutzerdefinierten Google-Funktion zur Faktenüberprüfung inspiriert. Im Gegensatz zum einstufigen Ansatz des Beispiels verwendet unser Agent mehrstufige Argumentation, um Behauptungen zu extrahieren, sie mit google_search zu überprüfen und strukturiertes JSON auszugeben.
Schritt 1 : Agent Development Kit installieren
Öffnen Sie in Cloud Shell einen neuen Terminaltab und erstellen Sie einen Ordner mit dem Namen my-agents. Rufen Sie auch den Ordner my-agents auf.
mkdir workspace-agents
cd workspace-agents
Erstellen wir nun eine virtuelle Python-Umgebung mit venv:
python -m venv .venv
Aktivieren Sie die virtuelle Umgebung so:
source .venv/bin/activate
So installieren Sie das ADK:
pip install google-adk
Sie können das adk-Dienstprogramm jetzt so aufrufen.
adk
Eine Liste mit Befehlen wird angezeigt.
$ adk
Usage: adk [OPTIONS] COMMAND [ARGS]...
Agent Development Kit CLI tools.
Options:
--version Show the version and exit.
--help Show this message and exit.
Commands:
api_server Starts a FastAPI server for agents.
conformance Conformance testing tools for ADK.
create Creates a new app in the current folder with prepopulated agent template.
deploy Deploys agent to hosted environments.
eval Evaluates an agent given the eval sets.
eval_set Manage Eval Sets.
run Runs an interactive CLI for a certain agent.
web Starts a FastAPI server with Web UI for agents.
Schritt 2 : Document Fact Checker-Agent mit dem ADK entwickeln
Wir verwenden jetzt adk, um mit dem Befehl adk create ein Gerüst für unseren Agenten zu erstellen. Der App-Name ist **(docfactcheckeragent)**, wie unten angegeben.
adk create docfactcheckeragent
Folgen Sie der Anleitung und wählen Sie Folgendes aus:
- Gemini-Modell zur Auswahl eines Modells für den Stamm-KI-Agenten.
- Wählen Sie Vertex AI als Backend aus.
- Ihre Standard-Google-Projekt-ID und -Region werden angezeigt. Wählen Sie die Standardeinstellung aus.
Choose a model for the root agent:
1. gemini-2.5-flash
2. Other models (fill later)
Choose model (1, 2): 1
1. Google AI
2. Vertex AI
Choose a backend (1, 2): 2
You need an existing Google Cloud account and project, check out this link for details:
https://google.github.io/adk-docs/get-started/quickstart/#gemini---google-cloud-vertex-ai
Enter Google Cloud project ID [YOUR_PROJECT_ID]:
Enter Google Cloud region [us-central1]:
Agent created in <YOUR_HOME_FOLDER>/workspace-agents/docfactcheckeragent:
- .env
- __init__.py
- agent.py
Sehen Sie sich den Ordner an, in dem eine Standardvorlage und die erforderlichen Dateien für den Agent erstellt wurden.
Zuerst kommt die Datei .env. Der Inhalt ist unten zu sehen:
GOOGLE_GENAI_USE_VERTEXAI=1
GOOGLE_CLOUD_PROJECT=YOUR_GOOGLE_PROJECT_ID
GOOGLE_CLOUD_LOCATION=YOUR_GOOGLE_PROJECT_REGION
Die Werte geben an, dass wir Gemini über Vertex AI verwenden, zusammen mit den entsprechenden Werten für die Google Cloud-Projekt-ID und den Standort.
Dann gibt es noch die Datei __init__.py, die den Ordner als Modul kennzeichnet und eine einzelne Anweisung enthält, mit der der Agent aus der Datei agent.py importiert wird.
from . import agent
Außerdem gibt es noch die Datei agent.py. Ersetzen Sie den Inhalt dieser Datei agent.py durch den unten gezeigten Code:
from google.adk.agents import Agent
from google.adk.tools import google_search
root_agent = Agent(
name='ai_auditor',
model='gemini-2.5-flash',
description="Fact-checks statements from a document and provides citations.",
instruction="""
You are an AI Auditor specialized in factual verification and evidence-based reasoning.
Your goal is to analyze text from a Google Doc, identify verifiable factual claims, and produce a concise, source-backed audit report.
### 🔍 TASK FLOW
1. **Extract Claims**
- Analyze the input text and identify factual claims that can be objectively verified.
- A factual claim is any statement that can be proven true or false with external evidence.
- Skip opinions, vague generalizations, or speculative language.
- List each claim as a string in a JSON array.
2. **Verify Claims**
- For each extracted claim:
- Use the `google_search` tool to find relevant, credible results.
- Evaluate at least the top 3 relevant URLs to determine the claim's accuracy.
- Cross-check multiple sources when possible to ensure confidence.
3. **Classify Findings**
- For each claim, determine one of the following verdicts:
- ✅ **True:** Supported by multiple reputable sources.
- ⚠️ **Misleading / Partially True:** Contains partially correct or context-dependent information.
- ❌ **False:** Contradicted by credible evidence.
- ❓ **Unverifiable:** Insufficient information to confirm or deny.
- Provide a **confidence score (0–100)** reflecting the strength of evidence.
4. **Record Evidence**
- For each claim, include:
- The **verdict**
- **Reasoning summary** (1–2 sentences)
- **List of citation URLs** used for verification
5. **Summarize Results**
- Compile a final report including:
- Total number of claims analyzed
- Distribution of verdicts (True / False / Misleading / Unverifiable)
- Brief overall conclusion (e.g., "Most claims are accurate but some lack supporting evidence.")
### 🧾 OUTPUT FORMAT
Return your final response in structured JSON format as follows:
{
"claims": [
{
"claim": "...",
"verdict": "True | False | Misleading | Unverifiable",
"confidence": 0-100,
"reasoning": "...",
"sources": ["https://...", "https://..."]
}
],
"summary": {
"total_claims": X,
"verdict_breakdown": {
"True": X,
"False": X,
"Misleading": X,
"Unverifiable": X
},
"overall_summary": "..."
}
}
### 🧠 ADDITIONAL INSTRUCTIONS
- Always prefer authoritative domains (.gov, .edu, .org, or major media).
- Avoid low-quality or user-generated content as primary sources.
- Be concise, accurate, and transparent about uncertainty.
""",
tools=[google_search], # Only use the search tool
)
Die wichtigsten Punkte für den oben genannten Quellcode sind:
- Wir definieren den KI-Agenten, indem wir ihm einen Namen geben, gefolgt vom Modell, der Beschreibung und einer sehr detaillierten Anleitung.
- Der Anweisungssatz ist der wichtigste Teil, der genau definiert, wie der Agent denken und arbeiten soll. Diese Struktur spiegelt die Arbeitsweise professioneller Faktenprüfer wider und macht die KI zu einer autonomen Prüfpipeline.
- Nachdem Sie diese Erklärung abgegeben haben, gewähren wir dem Agent über die
Google Search toolZugriff auf Informationen aus der realen Welt. Anstatt auf vortrainierte Daten zurückzugreifen, kann der Agent Live-Suchanfragen ausführen, Ergebnisse auswerten und aktuelle Quellenangaben bereitstellen.
Das macht das System zu einem KI-Agenten: Das Modell generiert nicht nur Antworten, sondern ergreift auch Maßnahmen (mit Tools), um Informationen zu überprüfen.
Schritt 3 : Agent lokal testen
Geben Sie im vorhandenen Terminalfenster den folgenden Befehl ein. Achten Sie darauf, dass Sie sich im übergeordneten Ordner (workspace-agents) befinden, der den Ordner docfactcheckeragent enthält.
adk web
Unten sehen Sie ein Beispiel für die Ausführung:
INFO: Started server process [1478]
INFO: Waiting for application startup.
+-----------------------------------------------------------------------------+
| ADK Web Server started |
| |
| For local testing, access at http://127.0.0.1:8000. |
+-----------------------------------------------------------------------------+
INFO: Application startup complete.
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
Klicken Sie auf den letzten Link. Daraufhin sollte eine Webkonsole angezeigt werden, in der Sie den Agent testen können. Die erste Interaktion ist von grundlegender Bedeutung: Wir müssen verstehen, was der Agent tatsächlich tun kann. Damit wird die Fähigkeit des Agents getestet, seine description und instruction text zusammenzufassen.
Der KI-Agent bietet eine kurze Zusammenfassung seiner Fähigkeiten, die auf seiner Beschreibung und seinen Anweisungen basiert.
Wir stellen ihr dann zwei Aussagen (The sky is blue due to Rayleigh scattering. The Earth is flat.) zur Verfügung und sie prüft den Inhalt erfolgreich und gibt eine gut strukturierte JSON-Antwort zurück.
Funktionsweise:
- Mit dem Tool „google_search“ werden relevante Seiten aus dem Web abgerufen.
- Das Gemini 2.5 Flash-Modell analysiert diese Snippets und klassifiziert die Richtigkeit.
- Das ADK übernimmt die Orchestrierung der Argumentation und sorgt dafür, dass die Logik Schritt für Schritt eingehalten wird.
In dieser lokalen Testphase können Sie den Workflow Ihres Agents validieren, bevor Sie ihn in Vertex AI Agent Engine bereitstellen, wo er mit Google Workspace-Tools wie Docs oder Sheets verbunden werden kann.
Zusammenfassend lässt sich sagen, dass wir mit dem Agent Development Kit (ADK) von Google einen leistungsstarken KI-Auditor-Agenten entwickelt haben. Unser Agent konnte Text lesen, Faktenbehauptungen identifizieren, glaubwürdige Quellen suchen (mit dem Tool „google_search“) und ein klares Urteil zurückgeben.
Wir haben alles lokal über die ADK-Weboberfläche erstellt und getestet und gesehen, wie der Agent eine Aussage wie die folgende analysiert hat:
The sky is blue due to Rayleigh scattering. The Earth is flat.
Der Agent hat eine Behauptung als true bestätigt und die andere als false gekennzeichnet. Das ist ein kleiner, aber passender Beweis dafür, dass unsere lokale Einrichtung perfekt funktioniert.
Jetzt ist es an der Zeit für den nächsten großen Schritt: die Migration von lokal zur Cloud. Das machen wir als Nächstes.
4. Agent in Vertex AI Agent Engine bereitstellen
Ein echter Agent ist nicht nur etwas, das Sie auf Ihrem Laptop testen. Er ist etwas, das Sie in großem Maßstab ausführen, in andere Systeme einbinden und für die Produktion in Ihren Apps bereitstellen können.
Warum bereitstellen?
Hier sind einige gute Gründe, Ihre Agents in der Cloud bereitzustellen.
- Skalierbarkeit: Hohe Anfragevolumina ohne lokale Laufzeitbeschränkungen verarbeiten.
- Zuverlässigkeit: Integriertes Monitoring und Autoscaling mit Korrekturen wie dem ADK-Tool-Konfigurationsupdate vom 18. Oktober 2025.
- Integrationsbereit: Stellen Sie einen API-Endpunkt für nahtlose Workspace-Aufrufe bereit.
Vorteile von Vertex AI Agent Engine
Vertex AI Agent Engine ist die Umgebung für Ihre bereitgestellten ADK-Agents – eine verwaltete Umgebung, die auf Zuverlässigkeit, Skalierbarkeit und Integration ausgelegt ist.
Dadurch erhält Ihr Agent:
- Persistenter Status und Speicher
- Ausführung integrierter Tools (z.B. Google Suche, Vertex AI-Modelle)
- API-Endpunkte für externe Aufrufe sichern
- Logging und Beobachtbarkeit über Cloud Logging
- Native Unterstützung für die Orchestrierung mehrerer Agenten
Kurz gesagt: Sie schreiben einmal mit dem ADK und skalieren dann mit der Agent Engine.
Schritt 1 : Bereitstellung vorbereiten
Bevor wir den Agenten in Vertex AI Agent Engine bereitstellen können, müssen wir einige Dinge erledigen. Für die Bereitstellung muss ein Google Cloud Storage-Bucket für die Agent-Artefakte erstellt werden. Außerdem muss eine requirements.txt-Datei bereitgestellt werden, damit alle Abhängigkeiten, die zum Ausführen des Agent-Codes erforderlich sind, für die Agent Engine-Laufzeitumgebung verfügbar sind.
Geben Sie in Ihrem Cloud Shell-Terminal den folgenden Befehl ein, um einen Bucket zu erstellen. Ersetzen Sie dabei YOUR_BUCKET_NAME, YOUR_PROJECT_ID und YOUR_PROJECT_REGION durch tatsächliche Werte, die für Ihr Projekt spezifisch sind:
gcloud storage buckets create gs://YOUR_BUCKET_NAME \
--project=YOUR_PROJECT_ID \
--location=YOUR_PROJECT_REGION
Erstellen Sie als Nächstes die folgende Datei requirements.txt im Stammordner (workspace-agents). Der Inhalt ist unten zu sehen:
google-cloud-aiplatform
google-adk
requests
Schritt 2 : Agent bereitstellen
Im nächsten Schritt stellen Sie Ihren Agent mit dem Befehl adk deploy in der Vertex AI Agent Engine bereit.
adk deploy agent_engine \
--project=YOUR_PROJECT_ID \
--region=YOUR_PROJECT_REGION \
--display_name "Doc Fact Checker" \
--staging_bucket gs://YOUR_BUCKET_NAME \
--requirements_file requirements.txt \
docfactcheckeragent/
Dadurch sollte ein Prozess gestartet werden, um unseren Agent in Agent Engine bereitzustellen. Dieser Vorgang ist zeitaufwendig und dauert etwa 5 Minuten. Auf übergeordneter Ebene passiert Folgendes:
- Die Agent-Erstellung beginnt: Die ADK-Befehlszeile verpackt Ihren Code, lädt ihn in Ihren Cloud Storage-Bucket hoch und löst die Erstellung einer neuen Agent Engine-Instanz durch Vertex AI aus.
- Sie erhalten einen Link zu den Logs, über den Sie den Cloud Logs-Explorer für Ihr Projekt aufrufen können. Klicken Sie darauf, um den detaillierten Fortschritt zu sehen, einschließlich der Einrichtungsschritte, der Installation von Abhängigkeiten und der Modellinitialisierung. Wenn etwas schiefgeht, z. B. eine Abhängigkeit fehlt oder ein Berechtigungsproblem auftritt, wird hier die Fehlermeldung angezeigt.
- Abschlussmeldung: Wenn die Bereitstellung abgeschlossen ist, wird im Terminal eine Bestätigungsmeldung mit Ihrer Reasoning Engine-ID angezeigt. Ein Beispiel dafür sehen Sie unten:
AgentEngine created. Resource name: projects/SOME_ID/locations/REGION/reasoningEngines/SOME_ID
Schritt 3 : Agent in der Cloud Console bestätigen (Agent Engine)
Rufen Sie nach Abschluss der Bereitstellung in der Google Cloud Console den Bereich Vertex AI → Agent Engine auf. Der bereitgestellte Agent sollte in der Konsole wie unten dargestellt aufgeführt sein:
🎉 Das war's! Ihr Agent ist jetzt in Vertex AI aktiv und kann in Google Workspace eingebunden oder direkt getestet werden.
Schritt 4 : Bereitstellungs-Agent testen
Herzlichen Glückwunsch! Ihr Agent ist jetzt in der Vertex AI Agent Engine verfügbar. Im nächsten Schritt testen Sie, ob die Bereitstellung korrekt erfolgt ist und das Modell auf Anfragen reagiert.
Dafür gibt es verschiedene Möglichkeiten, je nachdem, wie Sie am liebsten arbeiten:
- Über die Google Cloud Console: Eine visuelle Benutzeroberfläche, über die Sie Ihre bereitgestellten Agents direkt ansehen, verwalten und testen können.
- REST API (cURL): Ideal für Entwickler, die Anfragen manuell senden und Antworten prüfen möchten.
- Mit dem Vertex AI SDK für Python: Eine programmatischere Option zum Einbinden von Tests in Ihren Entwicklungs-Workflow.
Jeder Ansatz gibt Ihnen Aufschluss darüber, wie sich Ihr Agent nach der Bereitstellung verhält, d.h. ob er Anfragen verarbeitet, Sitzungen verwaltet oder Antworten zurückgibt. Ausführliche Schritte, Beispiele und erweiterte Konfigurationen für jede Methode finden Sie in der offiziellen Dokumentation.
Ihr KI-Auditor ist jetzt ein cloudbasierter Agent, der in Vertex AI Agent Engine bereitgestellt wird und mit google_search Fakten im großen Maßstab prüfen kann. Sie wird in einen zuverlässigen, API-gesteuerten digitalen Teamkollegen umgewandelt, der JSON-Code wie diesen ausgibt:
{ "claims": [{"claim": "The sky is blue...", "verdict": "True", "confidence": 95}] }
Das werden wir im nächsten Abschnitt direkt ausprobieren. Dort werden wir den Agent in ein Google-Dokument einbinden und die im Dokument enthaltenen Fakten validieren.
5. Faktencheck-Agent in Google Docs einbinden
In diesem Abschnitt verbinden wir alles miteinander und bringen den bereitgestellten Agenten in Google Docs. Mit wenigen Zeilen Apps Script können Sie ein Standard-Google-Dokument in einen KI-gestützten Editor umwandeln, der Inhalte automatisch analysieren und faktenchecken kann.
Schritt 1: Google Docs-Umgebung einrichten
Öffnen Sie zuerst ein neues oder vorhandenes Google-Dokument (docs.new).
Das Google-Dokument, das wir für diese Anleitung verwenden, enthält die folgenden Inhalte. Sie können diese oder Ihre eigenen Inhalte verwenden, die Sie auf Fakten prüfen möchten:
Climate change is mainly caused by solar activity cycles, not human activities. The Earth's temperature has not increased significantly in the last 100 years. Wind energy now produces more electricity than coal in every country in Europe. In 2015, nearly all world nations signed the Paris Agreement to limit global warming.
Schritt 2: Apps Script-Projekt und -Dateien einrichten
Für diese Einrichtung benötigen Sie zwei Dateien in Ihrem Apps Script-Projekt:
AIVertex.gs– übernimmt die gesamte Kommunikation mit Vertex AI und dem ADK-Agent.Code.gs– steuert die Google Docs-Benutzeroberfläche, die Menüs und die Dokumentaktionen.
Rufen Sie im Menü Extensions -> Apps Script auf, um den Editor zu öffnen. Über diesen Bereich stellen wir eine Verbindung zum bereitgestellten ADK-Agent her. Sie finden dort bereits eine Code.gs-Datei. Ersetzen Sie deren Inhalt durch den Code.gs-Code, der im nächsten Abschnitt bereitgestellt wird.
Sehen wir uns die einzelnen Punkte genauer an.
AIVertex.gs
Erstellen Sie eine neue Datei über das Pluszeichen neben dem Bereich „Dateien“ auf der linken Seite, wählen Sie sie als Script aus und kopieren Sie den folgenden Inhalt hinein.
const LOCATION = PropertiesService.getScriptProperties().getProperty('LOCATION');
const GEMINI_MODEL_ID = PropertiesService.getScriptProperties().getProperty('GEMINI_MODEL_ID');
const REASONING_ENGINE_ID = PropertiesService.getScriptProperties().getProperty('REASONING_ENGINE_ID');
const SERVICE_ACCOUNT_KEY = PropertiesService.getScriptProperties().getProperty('SERVICE_ACCOUNT_KEY');
const credentials = credentialsForVertexAI();
/**
* @param {string} statement The statement to fact-check.
*/
function requestLlmAuditorAdkAiAgent(statement) {
return UrlFetchApp.fetch(
`https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${credentials.projectId}/locations/${LOCATION}/reasoningEngines/${REASONING_ENGINE_ID}:streamQuery?alt=sse`,
{
method: 'post',
headers: { 'Authorization': `Bearer ${credentials.accessToken}` },
contentType: 'application/json',
muteHttpExceptions: true,
payload: JSON.stringify({
"class_method": "async_stream_query",
"input": {
"user_id": "google_sheets_custom_function_fact_check",
"message": statement,
}
})
}
).getContentText();
}
/**
* @param {string} prompt The Gemini prompt to use.
*/
function requestOutputFormatting(prompt) {
const response = UrlFetchApp.fetch(
`https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${credentials.projectId}/locations/${LOCATION}/publishers/google/models/${GEMINI_MODEL_ID}:generateContent`,
{
method: 'post',
headers: { 'Authorization': `Bearer ${credentials.accessToken}` },
contentType: 'application/json',
muteHttpExceptions: true,
payload: JSON.stringify({
"contents": [{
"role": "user",
"parts": [{ "text": prompt }]
}],
"generationConfig": { "temperature": 0.1, "maxOutputTokens": 2048 },
"safetySettings": [
{
"category": "HARM_CATEGORY_HARASSMENT",
"threshold": "BLOCK_NONE"
},
{
"category": "HARM_CATEGORY_HATE_SPEECH",
"threshold": "BLOCK_NONE"
},
{
"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
"threshold": "BLOCK_NONE"
},
{
"category": "HARM_CATEGORY_DANGEROUS_CONTENT",
"threshold": "BLOCK_NONE"
}
]
})
}
);
return JSON.parse(response).candidates[0].content.parts[0].text
}
/**
* Gets credentials required to call Vertex API using a Service Account.
* Requires use of Service Account Key stored with project.
*
* @return {!Object} Containing the Google Cloud project ID and the access token.
*/
function credentialsForVertexAI() {
const credentials = SERVICE_ACCOUNT_KEY;
if (!credentials) {
throw new Error("service_account_key script property must be set.");
}
const parsedCredentials = JSON.parse(credentials);
const service = OAuth2.createService("Vertex")
.setTokenUrl('https://oauth2.googleapis.com/token')
.setPrivateKey(parsedCredentials['private_key'])
.setIssuer(parsedCredentials['client_email'])
.setPropertyStore(PropertiesService.getScriptProperties())
.setScope("https://www.googleapis.com/auth/cloud-platform");
return {
projectId: parsedCredentials['project_id'],
accessToken: service.getAccessToken(),
}
}
Denken Sie daran, die Datei zu speichern.
Diese Datei bewirkt Folgendes:
- Authentifiziert sich sicher bei Vertex AI mit einem Dienstkontoschlüssel. Dadurch wird Ihr bereitgestellter ADK-Agent aufgerufen, um den Dokumenttext zu analysieren oder Fakten zu prüfen.
- Gemini wird für die intelligente Formatierung von Antworten verwendet , sodass die Ergebnisse für Menschen lesbar sind.
Code.gs
/**
* Adds a custom menu in Google Docs to run the AI Audit directly.
*/
function onOpen() {
DocumentApp.getUi()
.createMenu('AI Audit Tools')
.addItem('Run AI Audit', 'runAuditAndInsert')
.addToUi();
}
/**
* Returns the entire text content of the document.
*/
function getDocumentText() {
const doc = DocumentApp.getActiveDocument();
const body = doc.getBody();
let text = body.getText();
return text.trim();
}
/**
* Runs the AI Audit and inserts the result as text at the end of the document.
*/
function runAuditAndInsert() {
const docText = getDocumentText();
const result = runAudit(docText);
if (result) {
const doc = DocumentApp.getActiveDocument();
const body = doc.getBody();
// Append the audit result as a new paragraph at the end of the document
body.appendParagraph('AI Audit Result: ' + result);
}
}
/**
* Runs the AI Audit using ADK Agent and Gemini formatting.
*/
function runAudit(docText) {
console.log('[INFO] Starting AI audit process...');
if (!docText) {
console.log('[WARN] No text in document.');
return '⚠️ The document is empty. Please add some text to audit.';
}
// Check for excessive document length to avoid token limits
if (docText.length > 10000) {
console.log('[WARN] Document too long.');
return '⚠️ Document exceeds 10,000 characters. Please shorten the text.';
}
console.log('[STEP] Sending text to ADK Agent...');
const rawAudit = requestLlmAuditorAdkAiAgent(docText);
// Check if rawAudit is an error message
if (rawAudit.startsWith('ERROR:')) {
console.error('[ERROR] ADK Agent returned error:', rawAudit);
return rawAudit;
}
console.log('[STEP] Formatting AI response...');
let formatted;
try {
formatted = requestOutputFormatting(
`Here is a fact-checking result: ${rawAudit}.
Summarize it. Keep the main verdict and reasoning. Remove markdown and make it concise.`
);
} catch (error) {
console.error('[ERROR] Formatting failed:', error.toString());
return `ERROR: Failed to format audit result - ${error.toString()}`;
}
console.log('[SUCCESS] Audit completed successfully.');
console.log('[RESULT] Final Output:', formatted);
return formatted;
}
Diese Datei verbindet die Docs-Benutzeroberfläche mit der ADK-Logik oben. Damit können Sie die Überprüfung direkt über ein benutzerdefiniertes Google Docs-Menü auslösen. Auf übergeordneter Ebene wird Folgendes ausgeführt:
- Fügt in Google Docs ein benutzerdefiniertes Menü mit dem Namen „AI Audit Tools“ hinzu.
- Ruft den Text Ihres Dokuments ab und sendet ihn zur Analyse an Ihren ADK-Agenten.
- Zeigt die KI-generierten Prüfungsergebnisse im Dokument an.
Schritt 3 : Dienstkonto erstellen
Wenn Sie die Funktion zum Aufrufen von Agents in ein Google-Dokument einbinden, müssen wir dem Google-Dokument eine Identität zuweisen, damit es die richtige Rolle hat, um den in Agent Engine bereitgestellten Agent aufzurufen. Dazu verwenden wir ein Dienstkonto mit der richtigen Rolle: roles/aiplatform.user.
Führen Sie in Cloud Shell das folgende Skript schrittweise aus:
export PROJECT_ID="YOUR_PROJECT_ID"
export SA_NAME="docfactcheckeragentsa"
gcloud iam service-accounts create $SA_NAME \
--project=$PROJECT_ID \
--display-name="Doc Fact Checker Agent Service Account"
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
--role="roles/aiplatform.user"
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
--role="roles/iam.serviceAccountTokenCreator"
Dadurch wird das Dienstkonto mit den richtigen Berechtigungen erstellt.
Wir generieren einen JSON-Schlüssel für das Dienstkonto. Damit wird Ihr Apps Script-Projekt authentifiziert. So erhalten Sie den Schlüssel:
- Wechseln Sie in der Google Cloud Console zu IAM & Verwaltung > Dienstkonten.
- Klicken Sie auf das Dienstkonto, das Sie gerade erstellt haben.
- Rufen Sie den Tab „Schlüssel“ auf.
- Klicken Sie auf „Schlüssel hinzufügen“ → „Neuen Schlüssel erstellen“.
- Wählen Sie JSON aus und klicken Sie auf „Erstellen“.
- Eine JSON-Datei wird automatisch heruntergeladen. Bewahren Sie diese Datei an einem sicheren Ort auf. Sie fügen den Inhalt im nächsten Abschnitt in die Skripteigenschaften ein.
Schritt 4 : Skripteigenschaften hinzufügen
Kehren Sie zum Apps Script-Editor in Google Docs zurück.
Wenn Sie Ihr Script mit Ihren bereitgestellten Ressourcen verbinden möchten, rufen Sie Project Settings → Script Properties → Add Script Property auf.
Fügen Sie den Skripteigenschaften Folgendes hinzu:
LOCATION: Die Region Ihrer Vertex AI-Bereitstellung. z.B.us-central1GEMINI_MODEL_ID: Das zu verwendende Gemini-Modell. Verwenden Sie den Wert:gemini-2.5-flashREASONING_ENGINE_ID: Die bereitgestellte ADK-Agent-ID. Sie können sie über die Option „Agent Engine“ in der Konsole für den von Ihnen bereitgestellten Agenten abrufen. Sie sehen einen Ressourcennamen für den bereitgestellten KI-Agenten. Die Agent-ID ist der letzte numerische Wert im Ressourcennamen (d.h. dieRESOURCE_ID), z. B.projects/SOME_ID/locations/REGION/reasoningEngines/RESOURCE_ID.SERVICE_ACCOUNT_KEY: Kopieren Sie den gesamten Inhalt des JSON-Schlüssels, den Sie für das Dienstkonto heruntergeladen haben, das wir im vorherigen Schritt erstellt haben.
Klicken Sie auf Skripteigenschaften speichern.
Schritt 5 : OAuth2-Bibliothek hinzufügen
Für die Authentifizierung von API-Aufrufen ist in unserem Apps Script-Projekt die OAuth2-Bibliothek erforderlich.
So fügen Sie es hinzu:
- Zu
Services → Libraries - Klicken Sie auf
Add a Library. - Geben Sie die Script-ID ein:
1B7FSrk5Zi6L1rSxxTDgDEUsPzlukDsi4KGuTMorsTQHhGBzBkMun4iDF
Schritt 6 : Fact Checker Doc Agent in Google Docs testen
Wir sind beim letzten Schritt, um den Agent in Google Docs zu testen. Gehen Sie dazu so vor:
- Führen Sie im Apps Script-Editor die Funktion
onOpen()einmal aus. Dadurch wird in Google Docs ein neues Menü „AI Audit Tools“ hinzugefügt. - Kehren Sie zu Ihrem Dokument zurück. Im Hauptmenü sehen Sie einen zusätzlichen Menüpunkt mit dem Titel
AI Audit Tools. Klicken Sie darauf und dann aufRun AI Audit.
Hier ein Beispiel:
6. Bereinigen
Damit Ihrem Google Cloud-Konto keine laufenden Gebühren in Rechnung gestellt werden, ist es wichtig, die Ressourcen zu löschen, die wir während dieses Workshops erstellt haben.
Wenn Sie nicht mehr möchten, dass der Agent in Agent Engine bereitgestellt wird, können Sie ihn mit den folgenden Schritten löschen:
- Rufen Sie in der Google Cloud Console die Seite Vertex AI Agent Engine auf.
- Suchen Sie in der Liste der bereitgestellten Agents nach dem Agent, den Sie löschen möchten.
- Klicken Sie neben dem Namen des Agents auf das Dreipunkt-Menü (weitere Aktionen).
- Wählen Sie im Drop-down-Menü Löschen aus.
- Bestätigen Sie das Löschen, indem Sie im Bestätigungsdialogfeld auf Agent löschen klicken.
Als Best Practice sollten Sie auch das Dienstkonto löschen.
gcloud iam service-accounts delete ${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com
7. Glückwunsch
Sie haben Ihren KI-Agenten jetzt bereitgestellt, mit Google Docs verbunden und in Aktion gesehen – er analysiert, zieht Schlussfolgerungen und fasst Inhalte zusammen, und zwar genau dort, wo sich Ihre Inhalte befinden. Was wir hier entwickelt haben, ist nicht nur eine eigenständige Demo. Sie ist die Grundlage für die intelligente, agentengesteuerte Zusammenarbeit in Google Workspace.
Durch die Kombination der Schlussfolgerungsfunktionen des ADK mit den generativen Modellen von Gemini haben wir Google Docs in einen lebendigen, denkenden Assistenten verwandelt, der Ihren Text kontextbezogen lesen, prüfen und optimieren kann.
Dasselbe Konzept lässt sich problemlos auf Sheets, Präsentationen, Drive und Gmail übertragen. Stellen Sie sich Agents vor, die:
- Finanzdaten prüfen und Inkonsistenzen in Google Sheets kennzeichnen
- Automatisch Präsentationen und Zusammenfassungen in Google Präsentationen erstellen
- Dokumente in Drive intelligent kennzeichnen und organisieren
- Oder E‑Mails direkt in Gmail entwerfen und auf Fakten prüfen lassen
Diese Demonstration schafft die Grundlage für die Entwicklung von agentischen Workflows, die sich nahtlos in Ihre täglichen Workspace-Tools einfügen und statische Dokumente in dynamische KI-Assistenten verwandeln.