Utiliser un agent

Le code permettant d'interroger un agent est le même, qu'il s'exécute localement ou qu'il soit déployé à distance. Par conséquent, sur cette page, le terme agent fait référence à local_agent ou remote_agent de manière interchangeable. Étant donné que l'ensemble des opérations compatibles varie selon les frameworks, nous fournissons des instructions d'utilisation pour les modèles spécifiques aux frameworks:

Framework Description
LangChain Plus facile à utiliser pour les cas d'utilisation de base grâce à ses configurations et abstractions prédéfinies.
LangGraph Approche basée sur des graphes pour définir des workflows, avec des fonctionnalités avancées d'intervention humaine et de retour en arrière/de lecture.
AG2 (anciennement AutoGen) AG2 fournit un framework de conversation multi-agent en tant qu'abstraction de haut niveau pour créer des workflows LLM.

Pour les agents personnalisés qui ne sont pas basés sur l'un des modèles spécifiques au framework, procédez comme suit:

  1. Authentification des utilisateurs
  2. Obtenez une instance d'agent.
  3. Rechercher les opérations compatibles
  4. Interrogez l'agent.
  5. (Le cas échéant) Diffusez les réponses de l'agent.

Étape 1: Authentification des utilisateurs

Suivez les mêmes instructions que pour configurer votre environnement.

Étape 2: Obtenir une instance d'un agent

Pour interroger un agent, vous devez d'abord disposer d'une instance d'agent. Vous pouvez créer une instance ou obtenir une instance existante d'un agent.

Pour obtenir l'agent correspondant à un ID de ressource spécifique:

SDK Vertex AI pour Python

Exécutez le code suivant :

from vertexai import agent_engines

agent = agent_engines.get(RESOURCE_ID)

Vous pouvez également indiquer le nom complet de la ressource de l'agent:

agent = agent_engines.get("projects/PROJECT_ID/locations/LOCATION/reasoningEngines/RESOURCE_ID")

requêtes

Exécutez le code suivant :

from google import auth as google_auth
from google.auth.transport import requests as google_requests
import requests

def get_identity_token():
    credentials, _ = google_auth.default()
    auth_request = google_requests.Request()
    credentials.refresh(auth_request)
    return credentials.token

response = requests.get(
f"https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/reasoningEngines/RESOURCE_ID",
    headers={
        "Content-Type": "application/json; charset=utf-8",
        "Authorization": f"Bearer {get_identity_token()}",
    },
)

REST 

curl \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/reasoningEngines/RESOURCE_ID

Le reste de cette section suppose que vous disposez d'une instance nommée agent.

Étape 3: Opérations compatibles

Lorsque vous développez l'agent localement, vous avez accès aux opérations qu'il prend en charge et vous en connaissez les détails. Pour utiliser un agent déployé, vous pouvez énumérer les opérations qu'il prend en charge:

SDK Vertex AI pour Python

Exécutez le code suivant :

agent.operation_schemas()

requêtes

Exécutez le code suivant :

import json

json.loads(response.content).get("spec").get("classMethods")

REST

Représenté en spec.class_methods à partir de la réponse à la requête curl.

Le schéma de chaque opération est un dictionnaire qui documente les informations d'une méthode pour l'agent que vous pouvez appeler. Voici un exemple de schéma d'opération pour une opération synchrone:

La commande suivante fournit une liste de schémas au format JSON correspondant aux opérations de l'objet remote_app :

agent.operation_schemas()

Par exemple, voici le schéma de l'opération query d'un LangchainAgent:

{'api_mode': '',
 'name': 'query',
 'description': """Queries the Agent with the given input and config.
    Args:
        input (Union[str, Mapping[str, Any]]):
            Required. The input to be passed to the Agent.
        config (langchain_core.runnables.RunnableConfig):
            Optional. The config (if any) to be used for invoking the Agent.
    Returns:
        The output of querying the Agent with the given input and config.
""",            '        ',
 'parameters': {'$defs': {'RunnableConfig': {'description': 'Configuration for a Runnable.',
                                             'properties': {'configurable': {...},
                                                            'run_id': {...},
                                                            'run_name': {...},
                                                            ...},
                                             'type': 'object'}},
                'properties': {'config': {'nullable': True},
                               'input': {'anyOf': [{'type': 'string'}, {'type': 'object'}]}},
                'required': ['input'],
                'type': 'object'}}

Où :

  • name est le nom de l'opération (par exemple, agent.query pour une opération nommée query).
  • api_mode correspond au mode d'API de l'opération ("" pour synchrone, "stream" pour le streaming).
  • description est une description de l'opération basée sur la documentation de la méthode.
  • parameters est le schéma des arguments d'entrée au format de schéma OpenAPI.

Étape 4: Interroger l'agent

Pour interroger l'agent à l'aide de l'une de ses opérations compatibles (par exemple, query):

SDK Vertex AI pour Python 

agent.query(input={"messages": [
    ("user", "What is the exchange rate from US dollars to Swedish currency?")
]})

requêtes 

from google import auth as google_auth
from google.auth.transport import requests as google_requests
import requests

def get_identity_token():
    credentials, _ = google_auth.default()
    auth_request = google_requests.Request()
    credentials.refresh(auth_request)
    return credentials.token

requests.post(
    f"https://{LOCATION}-aiplatform.googleapis.com/v1/projects/{PROJECT_ID}/locations/{LOCATION}/reasoningEngines/{RESOURCE_ID}:query",
    headers={
        "Content-Type": "application/json; charset=utf-8",
        "Authorization": f"Bearer {get_identity_token()}",
    },
    data=json.dumps({"input": {
        "input": {"messages": [
            ("user", "What is the exchange rate from US dollars to Swedish currency?")
        ]},
    }})
)

REST 

curl \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://us-central1-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/reasoningEngines/RESOURCE_ID:query -d '{
  "input": {
    "input": {"messages": [
      ("user", "What is the exchange rate from US dollars to Swedish currency?")
    ]},
  }
}'

La réponse à la requête est une chaîne semblable à la sortie d'un test d'application locale :

{"input": "What is the exchange rate from US dollars to Swedish currency?",
 # ...
 "output": "For 1 US dollar you will get 10.7345 Swedish Krona."}

Étape 5: Lire les réponses de l'agent en streaming

Le cas échéant, vous pouvez diffuser une réponse de l'agent à l'aide de l'une de ses opérations (par exemple, stream_query):

SDK Vertex AI pour Python 

agent = agent_engines.get("projects/PROJECT_ID/locations/LOCATION/reasoningEngines/RESOURCE_ID")

agent.stream_query(input={"messages": [
    ("user", "What is the exchange rate from US dollars to Swedish currency?")
]})

requêtes 

from google import auth as google_auth
from google.auth.transport import requests as google_requests
import requests

def get_identity_token():
    credentials, _ = google_auth.default()
    auth_request = google_requests.Request()
    credentials.refresh(auth_request)
    return credentials.token

requests.post(
    f"https://{LOCATION}-aiplatform.googleapis.com/v1/projects/{PROJECT_ID}/locations/{LOCATION}/reasoningEngines/{RESOURCE_ID}:streamQuery",
    headers={
        "Content-Type": "application/json",
        "Authorization": f"Bearer {get_identity_token()}",
    },
    data=json.dumps({"input": {
        "input": {"messages": [
            ("user", "What is the exchange rate from US dollars to Swedish currency?")
        ]},
    }}),
    stream=True,
)

REST 

curl \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://us-central1-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/reasoningEngines/RESOURCE_ID:streamQuery?alt=sse -d '{
  "input": {
    "input": {"messages": [
      ("user", "What is the exchange rate from US dollars to Swedish currency?")
    ]},
  }
}'

Le moteur d'agent diffuse les réponses sous la forme d'une séquence d'objets générés de manière itérée. Par exemple, un ensemble de trois réponses peut se présenter comme suit:

{'actions': [{'tool': 'get_exchange_rate', ...}]}  # first response
{'steps': [{'action': {'tool': 'get_exchange_rate', ...}}]}  # second response
{'output': 'The exchange rate is 11.0117 SEK per USD as of 2024-12-03.'}  # final response

Étape suivante