Guide du développeur de l'API Interactions

L'API Interactions fournit une interface unifiée avec état pour créer des applications d'IA générative avec des modèles Gemini et des agents autonomes sur Gemini Enterprise Agent Platform. Utilisez l'API Interactions pour exécuter des conversations multitours, diffuser des réponses en temps réel, appliquer des sorties structurées, exécuter des appels de fonction et orchestrer des tâches de longue durée en arrière-plan.

Ce guide vous explique comment installer le SDK Google Gen AI, authentifier votre client et implémenter des workflows d'interaction courants. Pour en savoir plus sur le cycle de vie des interactions, consultez la présentation de l'API Interactions.

Avant de commencer

Avant d'envoyer des requêtes à l'API Interactions, configurez votre projet Google Cloudet votre environnement de développement :

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  2. Verify that billing is enabled for your Google Cloud project.

  3. Enable the Agent Platform API, if it is not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the API

  4. Make sure that you have the following role or roles on the project: Agent Platform User (roles/aiplatform.user)

    Check for the roles

    1. In the Google Cloud console, go to the IAM page.

      Go to IAM
    2. Select the project.

    3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

    4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

    Grant the roles

    1. In the Google Cloud console, go to the IAM page.

      Go to IAM
    2. Select the project.
    3. Click Grant access.

    4. In the New principals field, enter your user identifier. This is typically the identifier for a user in a workforce identity pool. For details, see Represent workforce pool users in IAM policies, or contact your administrator.

    5. Click Select a role, then search for the role.
    6. To grant additional roles, click Add another role and add each additional role.
    7. Click Save.

Concepts clés

Passez en revue les concepts suivants pour comprendre comment l'API Interactions gère l'état et les réponses :

  • Interaction : l'API Interactions est axée sur une ressource principale, à savoir Interaction. Un Interaction représente un tour complet dans une conversation ou une tâche, en suivant la chronologie des réflexions du modèle, des appels d'outils et des résultats finaux. Il fournit une enveloppe unifiée pour les interactions entre les requêtes et les réponses, ainsi que pour les workflows d'agents complexes en plusieurs étapes.
  • Rétention avec état : les interactions sont stockées côté serveur par défaut (store=True en Python ou store: true en TypeScript/JavaScript). Les interactions stockées sont conservées pendant sept jours, puis supprimées automatiquement. Définir store=False active le mode sans état, qui désactive la conservation côté serveur et est conforme à la conservation des données nulle (ZDR, Zero Data Retention). Le mode sans état désactive également l'enchaînement previous_interaction_id et l'exécution asynchrone (background=True).
  • Assistance pour les réponses : le SDK Google Gen AI version 2.3.0 et ultérieure fournit des propriétés pratiques sur la réponse à l'interaction, y compris interaction.output_text, interaction.output_image et interaction.output_audio. Utilisez interaction.output_text pour lire les réponses textuelles au lieu d'indexer manuellement le tableau des étapes (comme interaction.steps[-1].content[0].text).

Conditions requises

Avant d'intégrer l'API Interactions, assurez-vous que votre environnement et vos requêtes répondent aux exigences suivantes :

  • Compatibilité des versions du SDK : utilisez le SDK Google Gen AI unifié (>= 2.3.0 pour Python ou @google/genai >= 2.3.0 pour TypeScript et JavaScript).

    • La version 2.3.0 ou ultérieure est requise pour les propriétés d'assistance de réponse et les capacités de l'agent, tandis que la version 2.0.0 est compatible avec le schéma steps de base.
    • Les anciens SDK (google-cloud-aiplatform, @google-cloud/vertexai et google-generativeai) ne sont pas compatibles avec l'API Interactions.

  • Modèles compatibles : utilisez les modèles Gemini 3 ou ultérieurs compatibles. Les familles de modèles antérieures ne sont pas compatibles avec cette API. Pour obtenir la liste complète des modèles compatibles, consultez Modèles compatibles et Migrer vers les dernières versions des modèles.

  • Paramètres à portée de tour : les paramètres de configuration tels que tools, system_instruction et generation_config ne s'appliquent qu'au tour actuel. Transmettez ces paramètres à chaque tour d'interaction suivant si votre workflow les exige dans une conversation multitour.

Installer le SDK Google Gen AI

Installez ou mettez à niveau le SDK Google Gen AI (>= 2.3.0) pour la langue de votre choix :

Python

pip install --upgrade "google-genai>=2.3.0"

TypeScript / JavaScript

npm install "@google/genai>=2.3.0"

Authentifier votre client

Vous pouvez vous connecter à l'API Interactions sur Agent Platform à l'aide de l'une des méthodes d'authentification suivantes :

Se connecter à l'aide d'un projet Google Cloud avec les Identifiants par défaut de l'application (ADC)

Nous vous recommandons d'utiliser cette méthode d'authentification pour les charges de travail d'entreprise et les déploiements de production sur Google Cloud. Pour vous authentifier avec les Identifiants par défaut de l'application (ADC), initialisez le client avec les propriétés suivantes :

  • enterprise=True
  • project= Google Cloud project ID
  • location="global"

Si vous n'avez pas encore configuré d'identifiants locaux, exécutez gcloud auth application-default login.

Dans l'exemple de code suivant, remplacez PROJECT_ID par l'ID de votre projetGoogle Cloud .

Python

from google import genai

client = genai.Client(
    enterprise=True,
    project="PROJECT_ID",
    location="global",
)

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="Explain serverless computing in one sentence.",
)

print(interaction.output_text)

TypeScript / JavaScript

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({
    enterprise: true,
    project: "PROJECT_ID",
    location: "global",
});

const interaction = await ai.interactions.create({
    model: "gemini-3.8-flash",
    input: "Explain serverless computing in one sentence.",
});

console.log(interaction.output_text);

REST

curl -X POST "https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/interactions" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.8-flash",
    "input": [{
      "role": "user",
      "content": [{
        "type": "text",
        "text": "Explain serverless computing in one sentence."
      }]
    }]
  }'

Se connecter en mode express (clé API)

Nous vous recommandons d'utiliser cette méthode d'authentification pour le prototypage rapide, les scripts légers ou les environnements qui s'authentifient avec une clé API. Transmettez votre clé API lors de l'initialisation du client ou dans l'en-tête HTTP x-goog-api-key.

Dans l'exemple de code suivant, remplacez API_KEY par votre clé API.

Python

from google import genai

client = genai.Client(
    enterprise=True,
    api_key="API_KEY",
)

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="Explain serverless computing in one sentence.",
)

print(interaction.output_text)

TypeScript / JavaScript

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({
    enterprise: true,
    apiKey: "API_KEY",
});

const interaction = await ai.interactions.create({
    model: "gemini-3.8-flash",
    input: "Explain serverless computing in one sentence.",
});

console.log(interaction.output_text);

REST

curl -X POST "https://aiplatform.googleapis.com/v1beta1/locations/global/interactions" \
  -H "x-goog-api-key: API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.8-flash",
    "input": [{
      "role": "user",
      "content": [{
        "type": "text",
        "text": "Explain serverless computing in one sentence."
      }]
    }]
  }'

Workflows d'interaction courants

Une fois votre client configuré, vous pouvez utiliser la méthode interactions.create pour créer des conversations multitours, diffuser des jetons de sortie en temps réel, générer du code JSON validé par un schéma, appeler des fonctions externes et exécuter des agents autonomes.

Gérer les conversations multitours avec état

Contrairement aux API de chat sans état qui vous obligent à renvoyer l'intégralité de l'historique des messages à chaque requête, l'API Interactions gère l'état de la conversation sur le serveur par défaut (store=True en Python ou store: true en TypeScript/JavaScript).

Pour poursuivre une conversation existante, transmettez le id de l'interaction précédente au paramètre previous_interaction_id. Agent Platform récupère automatiquement le contexte de conversation stocké et ajoute le nouveau tour. Si vous définissez store=False (store: false en TypeScript/JavaScript), la persistance côté serveur est désactivée et vous ne pouvez pas enchaîner les tours suivants avec previous_interaction_id.

Python

# Turn 1: Start a conversation (store=True by default)
turn1 = client.interactions.create(
    model="gemini-3.8-flash",
    input="Hi! My name is John. I am working on AI agents.",
    store=True,
)
print(f"Turn 1: {turn1.output_text}")

# Turn 2: Reference the stored conversation state using previous_interaction_id
turn2 = client.interactions.create(
    model="gemini-3.8-flash",
    input="What is my name?",
    previous_interaction_id=turn1.id,
)
print(f"Turn 2: {turn2.output_text}")

TypeScript / JavaScript

// Turn 1: Start a conversation (store: true by default)
const turn1 = await ai.interactions.create({
    model: "gemini-3.8-flash",
    input: "Hi! My name is John. I am working on AI agents.",
    store: true,
});
console.log(`Turn 1: ${turn1.output_text}`);

// Turn 2: Reference the stored conversation state using previous_interaction_id
const turn2 = await ai.interactions.create({
    model: "gemini-3.8-flash",
    input: "What is my name?",
    previous_interaction_id: turn1.id,
});
console.log(`Turn 2: ${turn2.output_text}`);

Diffuser des réponses en temps réel

Pour réduire la latence perçue des applications interactives, vous pouvez diffuser les réponses du modèle à mesure qu'elles sont générées. Définissez stream=True (stream: true en TypeScript/JavaScript) lorsque vous appelez interactions.create pour recevoir un flux itérable d'événements envoyés par le serveur. Filtrez les événements step.delta pour afficher les blocs de texte incrémentaux à mesure qu'ils arrivent :

Python

response = client.interactions.create(
    model="gemini-3.8-flash",
    input="Write a short poem about debugging.",
    stream=True,
)

for event in response:
    if event.event_type == "step.delta" and hasattr(event.delta, "text"):
        print(event.delta.text, end="", flush=True)
print()

TypeScript / JavaScript

const responseStream = await ai.interactions.create({
    model: "gemini-3.8-flash",
    input: "Write a short poem about debugging.",
    stream: true,
});

for await (const event of responseStream) {
    if (event.event_type === "step.delta" && event.delta && "text" in event.delta) {
        process.stdout.write(event.delta.text);
    }
}
console.log();

Générer une sortie structurée

Lorsque votre application nécessite des réponses dans un format prévisible et lisible par machine, vous pouvez contraindre la sortie du modèle à correspondre à un schéma JSON spécifique. Transmettez votre schéma cible (par exemple, un schéma JSON de modèle Pydantic en Python ou un objet de schéma Type en TypeScript/JavaScript) directement au paramètre polymorphe response_format :

Python

from pydantic import BaseModel, Field

class Book(BaseModel):
    title: str = Field(description="The title of the book")
    author: str = Field(description="The book's author")
    year_published: int

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="Recommend one famous sci-fi book.",
    response_format=Book.model_json_schema(),
)

# The output text is valid JSON matching the Book schema
print(interaction.output_text)

TypeScript / JavaScript

import { Type } from "@google/genai";

const BookSchema = {
    type: Type.OBJECT,
    properties: {
        title: { type: Type.STRING, description: "The title of the book" },
        author: { type: Type.STRING, description: "The book's author" },
        yearPublished: { type: Type.INTEGER },
    },
    required: ["title", "author", "yearPublished"],
};

const interaction = await ai.interactions.create({
    model: "gemini-3.8-flash",
    input: "Recommend one famous sci-fi book.",
    response_format: BookSchema,
});

console.log(interaction.output_text);

Utiliser l'appel de fonction (utilisation d'outils)

L'appel de fonction permet à un modèle de demander l'exécution de fonctions personnalisées ou d'API externes pour recueillir des informations avant de formuler une réponse finale. Dans un workflow d'interaction avec état, l'appel de fonction suit un modèle à deux tours :

  1. Déclarer et transmettre des outils : fournissez vos déclarations de fonction dans le paramètre tools de la requête initiale.
  2. Exécuter et renvoyer les résultats : inspectez les étapes de réponse (interaction.steps) pour les étapes function_call, exécutez votre fonction locale à l'aide de arguments fourni par le modèle et envoyez une interaction de suivi contenant un élément function_result lié par call_id et previous_interaction_id.

Python

# Define a declarative function tool schema
stock_tool = {
    "type": "function",
    "name": "get_stock_price",
    "description": "Gets the stock price for a given ticker symbol.",
    "parameters": {
        "type": "object",
        "properties": {
            "ticker": {"type": "string", "description": "The stock ticker symbol"}
        },
        "required": ["ticker"],
    },
}

def get_stock_price(ticker: str) -> float:
    """Executes the local tool function."""
    if ticker.upper() == "GOOG":
        return 175.50
    return 100.0

# Turn 1: Pass the tool declaration to the model
interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="What is the stock price of GOOG?",
    tools=[stock_tool],
)

# Inspect the interaction steps for function call requests
for step in interaction.steps:
    if step.type == "function_call" and step.name == "get_stock_price":
        ticker_arg = step.arguments.get("ticker")
        price = get_stock_price(ticker_arg)

        # Turn 2: Submit the function execution result to the conversation
        final_turn = client.interactions.create(
            model="gemini-3.8-flash",
            input=[{
                "type": "function_result",
                "call_id": step.id,
                "result": {"price": price},
            }],
            previous_interaction_id=interaction.id,
        )
        print(final_turn.output_text)

TypeScript / JavaScript

// Define a declarative function tool schema
const stockTool = {
    type: "function",
    name: "getStockPrice",
    description: "Gets the stock price for a given ticker symbol.",
    parameters: {
        type: "object",
        properties: {
            ticker: { type: "string", description: "The stock ticker symbol" },
        },
        required: ["ticker"],
    },
};

function getStockPrice({ ticker }: { ticker: string }): number {
    if (ticker.toUpperCase() === "GOOG") return 175.50;
    return 100.00;
}

// Turn 1: Pass the tool declaration to the model
const interaction = await ai.interactions.create({
    model: "gemini-3.8-flash",
    input: "What is the stock price of GOOG?",
    tools: [stockTool],
});

// Inspect the interaction steps for function call requests
for (const step of interaction.steps ?? []) {
    if (step.type === "function_call" && step.name === "getStockPrice") {
        const tickerArg = step.arguments.ticker as string;
        const price = getStockPrice({ ticker: tickerArg });

        // Turn 2: Submit the function execution result to the conversation
        const finalTurn = await ai.interactions.create({
            model: "gemini-3.8-flash",
            input: [{
                type: "function_result",
                call_id: step.id,
                result: { price },
            }],
            previous_interaction_id: interaction.id,
        });
        console.log(finalTurn.output_text);
    }
}

Exécuter des agents et des tâches longues en arrière-plan

En plus des modèles de fondation, l'API Interactions vous permet d'appeler des agents autonomes spécialisés à l'aide du paramètre agent :

  • antigravity-preview-05-2026 : agent géré à usage général avec exécution de code, gestion de fichiers et navigation Web dans un environnement Linux sécurisé en bac à sable. Pour en savoir plus, consultez Interagir avec les agents.
  • deep-research-preview-04-2026 : agent Gemini Deep Research, qui planifie et exécute des tâches de recherche sur le Web en plusieurs étapes, et synthétise les résultats de plusieurs sources dans des rapports complets. Pour en savoir plus, consultez Utiliser l'agent Gemini Deep Research.
  • Agents personnalisés : ressources d'agent personnalisées configurées et provisionnées avec client.agents.create().

Comme les workflows d'agent prennent souvent plusieurs minutes, exécutez-les de manière asynchrone en arrière-plan en définissant background=True. L'API renvoie immédiatement un objet Interaction avec un id que vous pouvez interroger à l'aide de client.interactions.get() jusqu'à ce que interaction.status passe à completed :

Avant d'essayer cet exemple, remplacez PROJECT_ID par l'ID de votre projetGoogle Cloud .

import time
from google import genai

client = genai.Client(
    enterprise=True,
    project="PROJECT_ID",
    location="global",
)

interaction = client.interactions.create(
    input="Analyze competitive positioning for solar energy providers.",
    agent="deep-research-preview-04-2026",
    background=True,
)

print(f"Research started: {interaction.id}")

while True:
    interaction = client.interactions.get(interaction.id)
    if interaction.status == "completed":
        print(interaction.output_text)
        break
    elif interaction.status in ("failed", "cancelled"):
        print(f"Research ended with status: {interaction.status}")
        break
    time.sleep(10)

Accéder aux fichiers Cloud Storage importés

Vous pouvez utiliser l'API Interactions pour accéder aux fichiers Cloud Storage importés. Consultez l'exemple ci-dessous :

from google import genai

# Credentials must belong to an identity with storage.objects.get permissions
client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input=[
        {"type": "text", "text": "Summarize the attached document:"},
        {
            "type": "document",
            "uri": "gs://my-secure-bucket/quarterly_report.pdf",
            "mime_type": "application/pdf"
        }
    ],
)

print(interaction.output_text)

Lorsque vous transmettez des URI Cloud Storage (par exemple, gs://bucket-name/path/to/file) à l'API Interactions, les requêtes sont évaluées à l'aide des identifiants de l'utilisateur final. L'API récupère les objets Cloud Storage à l'aide de l'identité de l'appelant authentifié plutôt que d'un agent de service de projet en arrière-plan.

Pour transmettre des fichiers Cloud Storage dans une demande d'interaction, le compte principal appelant (compte utilisateur, compte de service ou identité fédérée) doit disposer de l'autorisation storage.objects.get pour tous les objets référencés.

Configurer des rôles IAM pour accéder aux fichiers Cloud Storage

Attribuez l'un des rôles prédéfinis standards qui incluent l'autorisation storage.objects.get :

  • Lecteur des objets Storage (roles/storage.objectViewer) : accès en lecture aux objets (recommandé).
  • Utilisateur d'objets Storage (roles/storage.objectUser) : accès en lecture et en écriture aux objets.

Pour accorder l'accès à un compte utilisateur à l'aide de Google Cloud CLI, utilisez la commande suivante :

gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="user:user-email@example.com" \
    --role="roles/storage.objectViewer"

Pour accorder l'accès à un compte de service d'appel spécifique, utilisez la commande suivante :

gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="serviceAccount:sa-name@PROJECT_ID." \
    --role="roles/storage.objectViewer"

Résoudre les problèmes d'accès aux fichiers Cloud Storage

Si le compte principal appelant ne dispose pas des autorisations suffisantes, l'API Interactions renvoie une erreur 403 Forbidden semblable à la suivante :

Access error:
PERMISSION_DENIED - 403 Forbidden: Calling principal lacks
storage.objects.get on one or more GCS URIs.

Pour résoudre ce problème, attribuez le rôle Lecteur des objets Storage (roles/storage.objectViewer) sur le bucket ou l'objet à l'appelant authentifié.

Si l'objet spécifié n'existe pas ou si les autorisations du bucket empêchent l'appelant de voir si l'objet existe, l'API Interactions renvoie une erreur 404 Not Found semblable à la suivante :

Access error:
NOT_FOUND - 404 Not Found: The object does not exist, or bucket
permissions prevent revealing object existence.

Pour résoudre ce problème, vérifiez que l'URI Cloud Storage est correct et assurez-vous que l'appelant authentifié dispose d'un accès en lecture au bucket.

Workflows REST avancés

Pour l'automatisation basée sur le shell, les pipelines CI/CD ou les environnements sans environnement d'exécution Python ou TypeScript/JavaScript, vous pouvez appeler l'API Interactions directement sur HTTP à l'aide de curl.

Point de terminaison REST

Envoyez des requêtes POST au point de terminaison suivant de l'API Interactions :

POST https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/interactions

Remplacez les variables suivantes dans vos requêtes :

  • PROJECT_ID : ID de votre projet Google Cloud .
  • LOCATION : définissez sur global (ou sur une région personnalisée compatible si votre configuration l'exige).

Définir des variables d'environnement et l'authentification

Avant d'exécuter les exemples curl dans les sections suivantes, exportez l'ID de votre projet, l'ID du modèle ou de l'agent cible, ainsi qu'un jeton d'accès OAuth 2.0 généré à partir des Identifiants par défaut de l'application :

PROJECT_ID="PROJECT_ID"
MODEL_ID="gemini-3.8-flash"
AGENT_ID="deep-research-preview-04-2026"
ACCESS_TOKEN=$(gcloud auth print-access-token)

Format de réponse synchrone

Une requête POST synchrone renvoie un objet interaction JSON qui inclut les métadonnées uniques d'interaction id, d'exécution status, de conversation steps et de jeton usage :

{
  "id": "your-interaction-id",
  "status": "completed",
  "steps": [
    {
      "type": "model_output",
      "content": [
        {
          "type": "text",
          "text": "Serverless computing is a cloud execution model where the cloud provider dynamically manages the allocation and provisioning of servers, charging customers based on actual usage rather than pre-purchased capacity."
        }
      ]
    }
  ],
  "usage": {
    "total_tokens": 24751,
    "total_input_tokens": 23894,
    "total_output_tokens": 857
  },
  "created": "2026-05-08T10:44:43Z",
  "updated": "2026-05-08T10:44:43Z",
  "environment_id": "your-environment-id",
  "object": "interaction"
}

Poursuivre une interaction avec état multitour

Pour poursuivre une conversation stockée via REST, transmettez le id d'une réponse précédente dans le champ previous_interaction_id du corps de la requête JSON.

Avant d'essayer cet exemple, remplacez PREVIOUS_INTERACTION_ID par le id renvoyé par une interaction précédente.

curl -X POST "https://aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/global/interactions" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "'"${MODEL_ID}"'",
    "store": true,
    "previous_interaction_id": "PREVIOUS_INTERACTION_ID",
    "input": [{
      "role": "user",
      "content": [{
        "type": "text",
        "text": "Can you elaborate on that?"
      }]
    }]
  }'

Diffuser la sortie avec des événements envoyés par le serveur

Pour diffuser des mises à jour incrémentielles sur REST, incluez "stream": true dans le corps de la requête JSON :

curl -X POST "https://aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/global/interactions" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "'"${MODEL_ID}"'",
    "stream": true,
    "input": [{
      "role": "user",
      "content": [{
        "type": "text",
        "text": "Write a long story about space travel."
      }]
    }]
  }'

Lorsque "stream": true est défini, le serveur répond avec Transfer-Encoding: chunked et Content-Type: text/event-stream (événements envoyés par le serveur). Chaque événement du flux inclut un préfixe data: contenant une charge utile JSON avec le contenu du delta de pas et de event_type. curl maintient automatiquement la connexion HTTP ouverte et écrit les blocs entrants dans stdout en temps réel jusqu'à la fin de l'interaction.

Exécuter un agent géré en arrière-plan

Pour démarrer une tâche d'agent géré de longue durée de manière asynchrone sur REST, spécifiez la agent cible, définissez "background": true et configurez "environment": "remote" :

curl -X POST "https://aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/global/interactions" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "agent": "'"${AGENT_ID}"'",
    "environment": "remote",
    "background": true,
    "input": [{
      "role": "user",
      "content": [{
        "type": "text",
        "text": "Analyze competitive positioning for commercial solar energy providers."
      }]
    }]
  }'

Étapes suivantes