Évaluer les tours de conversation d’un agent avec un scorer distant

Un signal de scorer distant évalue chaque tour de conversation d’agent terminé à l’aide d’un point de terminaison HTTP que vous hébergez, et non d’un juge LLM. À la fin d’un tour de conversation, le worker d’évaluation des agents de W&B Weave envoie ce tour à votre point de terminaison via une requête HTTP POST, puis enregistre la réponse sous forme de feedback associé au tour. Le résultat s’affiche sous forme de tag ou de score dans l’onglet Signals de la vue Agents. Cette page porte sur les scorers distants appliqués aux tours de conversation d’agent. Pour évaluer des appels tracés avec @weave.op, voir Évaluer des appels avec des scorers distants. La configuration des scorers distants s’effectue avec le SDK Python ou dans l’interface Weave. Le SDK TypeScript n’inclut pas RemoteScorer.

Fonctionnement de l’évaluation des tours de conversation d’un agent

Un tour de conversation d’un agent est évalué selon la séquence suivante :

Un tour de conversation se termine. Lorsqu’un span racine (un span sans parent) se termine, Weave le considère comme un tour de conversation terminé et émet un événement weave.genai.turn_ended.
Le worker d’évaluation des agents charge les signaux actifs du projet qui ciblent weave.genai.turn_ended, puis applique les filtres et le taux d’échantillonnage de chaque signal.
Pour chaque RemoteScorer d’un signal correspondant, le worker construit une requête schema_version: 2 à partir du span du tour de conversation, messages compris, résout les identifiants d’authentification du scorer, vérifie que l’URL du point de terminaison figure parmi les hôtes autorisés, puis envoie la requête POST.
Le worker valide la réponse et enregistre le résultat sous forme de feedback associé au tour de conversation. Les tags et les scores s’affichent dans l’onglet Signals.

Weave n’évalue que les tours de conversation terminés. Les spans individuels de LLM et d’outil, tout comme les conversations entières, ne peuvent pas faire l’objet d’une évaluation à distance. Un signal de scorer distant est un Monitor dont op_names vaut ["weave.genai.turn_ended"], que vous le créiez dans l’interface utilisateur ou avec le SDK. En cas d’échec, le worker relance la tentative avec la même Idempotency-Key, dans la limite de trois tentatives au cours des 30 secondes suivant la première. Les réponses 5xx, 408 et 429 donnent lieu à une nouvelle tentative. Un dépassement du délai d’attente consomme la totalité des 30 secondes : une requête ayant expiré n’est donc pas relancée. Les autres réponses 4xx ne sont pas relancées non plus. Si votre point de terminaison ne peut pas évaluer un tour de conversation à temps, renvoyez rapidement 503 plutôt que de laisser la requête expirer, afin que Weave la relance. L’évaluation des tours de conversation d’un agent nécessite le format de résultat structuré, car Weave stocke les tags et les scores sous forme de colonnes de feedback typées.

Activer l’évaluation à distance

L’évaluation à distance est désactivée tant qu’elle n’a pas été activée pour votre organisation ou votre déploiement, et le worker d’évaluation n’appelle le point de terminaison d’un évaluateur que si son hôte figure sur une liste d’autorisation. La procédure d’activation dépend de votre type de déploiement. Cloud mutualisé Pour activer les évaluateurs distants pour une organisation, un administrateur de l’organisation ou un administrateur de la facturation doit :

Ouvrir https://wandb.ai/account-settings/[ORG]/settings, en remplaçant [ORG] par l’organisation propriétaire de votre projet.
Sélectionner l’onglet Remote scoring.
Activer Enable remote scoring.
Sous Allowed hosts, cliquer sur Add host et saisir chaque hôte que les évaluateurs distants sont autorisés à appeler. Lorsque l’évaluation à distance est activée, au moins un hôte est requis pour enregistrer. Laisser le port vide pour autoriser tous les ports de cet hôte.
Cliquer sur Save settings.

Cloud dédié Demandez à W&B d’activer l’évaluation à distance pour votre déploiement et d’en configurer les hôtes autorisés. Autogéré Si vous exécutez W&B Weave dans un déploiement W&B Autogéré, définissez ces variables d’environnement via extraEnv sur chaque worker d’évaluation : le worker d’évaluation en ligne, le worker d’évaluation des appels et le worker d’évaluation des agents.

Variable d’environnement	Par défaut	Effet
`WF_SCORING_WORKER_REMOTE_SCORING_ENABLED`	`false`	Active les requêtes sortantes vers les scorers distants. Si la valeur est `false`, aucun scorer distant ne s’exécute, quels que soient les autres paramètres.
`WF_SCORING_WORKER_REMOTE_HTTP_TIMEOUT_SECONDS`	`30`	Délai d’expiration de chaque requête envoyée à un point de terminaison de scorer.
`WF_SCORING_WORKER_REMOTE_SCORER_ALLOWED_HOSTS`	vide	Liste d’autorisation définie par l’opérateur, composée d’entrées `host` ou `host:port` séparées par des virgules.
`WF_SCORING_WORKER_REMOTE_SCORER_VALIDATE_HOSTS`	`true`	Applique les listes d’hôtes autorisés. Les adresses privées, de bouclage et de métadonnées cloud sont rejetées, quelle que soit la valeur de ce paramètre.
`WF_SCORING_WORKER_REMOTE_SCORER_ALLOW_INSECURE_HTTP`	`false`	Autorise les URL de point de terminaison en `http://`.
`WF_SCORING_WORKER_REMOTE_SCORER_ALLOWED_PRIVATE_CIDRS`	vide	Réseaux CIDR séparés par des virgules, par exemple `10.0.0.0/8`, dont les adresses privées peuvent être appelées par les scorers distants.

Pour afficher les paramètres d’évaluation à distance et les options de scorer dans l’interface Weave, définissez également GORILLA_GATE_WEAVE_REMOTE_SCORING=true sur le serveur W&B. Règles relatives aux hôtes autorisés Le worker de scoring vérifie la conformité de chaque URL de point de terminaison de scorer aux règles suivantes, ainsi que, séparément, celle de l’URL du point de terminaison de jeton OAuth lorsqu’un scorer utilise OAuth :

Une entrée correspond à un hôte exact, avec un port facultatif. Une entrée sans port autorise n’importe quel port sur cet hôte.
Une entrée commençant par *. correspond aux sous-domaines de tout niveau, mais pas au domaine lui-même. *.corp.example.com correspond à a.corp.example.com et à a.b.corp.example.com, mais pas à corp.example.com. Le suffixe qui suit *. doit comporter au moins deux labels ; *.com est donc rejeté. Un caractère générique ne peut pas être associé à une adresse IP.
Lorsqu’il existe à la fois une liste d’autorisation de l’opérateur et une liste d’autorisation de l’organisation, l’URL doit respecter les deux. Une liste d’autorisation de l’opérateur vide n’ajoute aucune restriction. En l’absence de toute liste d’autorisation, le worker rejette tous les hôtes.
Les adresses de bouclage, privées, internes et de métadonnées cloud sont rejetées. En environnement Autogéré, les adresses privées appartenant aux réseaux répertoriés dans WF_SCORING_WORKER_REMOTE_SCORER_ALLOWED_PRIVATE_CIDRS sont autorisées.
HTTPS est requis, sauf si le déploiement autorise le HTTP non sécurisé.
Les redirections ne sont pas suivies.

Créer le point de terminaison du scorer

Votre point de terminaison accepte une requête POST JSON envoyée par Weave et renvoie un score au format JSON. Pour une implémentation de référence, consultez Exemple de code.

Requête

Weave envoie une requête HTTP POST par cible évaluée à l’URL du point de terminaison du scorer, avec les en-têtes suivants :

En-tête	Valeur
`Content-Type`	`application/json`
`Authorization`	`Bearer [TOKEN]`
`Idempotency-Key`	Une clé dérivée de la cible évaluée, de la version du monitor et de la version du scorer.
`X-Correlation-ID`	Un ID de corrélation pour cette requête.
`X-Weave-Schema-Version`	`1` ou `2`, identique à la valeur de `schema_version` dans le corps.

Weave peut transmettre plusieurs fois la même tentative d’évaluation. Si votre point de terminaison l’exige, utilisez Idempotency-Key pour dédupliquer les requêtes. La clé est stable pour une version de requête donnée : une requête V1 et une requête V2 portant sur le même Call ont donc des clés différentes. Chaque corps de requête contient les champs de premier niveau suivants :

Champ	Description
`schema_version`	Entier, `1` ou `2`.
`scoring_call_id`, `scoring_trace_id`	Identifiants de cette tentative d’évaluation.
`monitor`	`name` et `version_digest` du monitor qui a sélectionné la cible.
`scorer`	`name`, `ref` et `config` (facultatif). `config` est le mappage défini sur le `RemoteScorer`, transmis tel quel.
`triggered_at`	Horodatage ISO 8601 facultatif.

Weave omet les champs facultatifs sans valeur au lieu de les envoyer avec la valeur null. Weave peut ajouter des champs facultatifs à une version sans en modifier le numéro : ignorez donc les champs que vous ne reconnaissez pas. Les corps de requête et de réponse sont limités à 1 Mio chacun et ne contiennent que du texte JSON, jamais d’images, d’audio ni de vidéo. Une cible qui dépasse ces limites n’est pas envoyée et n’est donc pas évaluée. Chaque requête ne contient qu’une seule cible. Une requête de tour de conversation d’agent comporte deux numéros de version. Le champ schema_version de premier niveau correspond à la version de l’enveloppe, qui vaut 2 pour les tours de conversation d’agent. Les données évaluées se trouvent dans scoring_target, une union étiquetée comportant trois champs :

type : le type de cible. agent_turn pour un tour de conversation. Le contrat définit également call, que l’évaluation des tours de conversation d’agent n’envoie jamais.
schema_version : la version de la charge utile pour ce type. Elle évolue indépendamment de la version de l’enveloppe. La charge utile agent_turn est en version 1.
payload : les données correspondant à ce type.

Vérifiez d’abord la version de l’enveloppe, puis examinez scoring_target.type et scoring_target.schema_version ensemble pour choisir comment évaluer la charge utile. Renvoyez une erreur 4xx pour toute combinaison que votre point de terminaison ne prend pas en charge, par exemple call si vous n’évaluez que des tours de conversation d’agent. La charge utile agent_turn en version 1 comporte les champs suivants :

Champ	Description
`event_type`	`weave.genai.turn_ended`.
`project_id`	Le projet, au format `[YOUR-TEAM]/[YOUR-PROJECT]`.
`trace_id`, `span_id`	Identifiants du span racine du tour de conversation.
`span_name`	Le nom du span, par exemple `invoke_agent sample-support-agent`.
`operation_name`	Le nom de l’opération GenAI, par exemple `invoke_agent`. `null` si la trace ne l’a pas enregistré.
`started_at`, `ended_at`	Horodatages ISO 8601.
`conversation`	`id` et `name`. Chacun vaut `null` si la trace ne l’a pas enregistré.
`agent`	`name`, `version` et `description`. Chacun vaut `null` si la trace ne l’a pas enregistré.
`status`	`code`, `message` et `error_type`. `code` vaut `UNSET`, `OK` ou `ERROR`. `message` et `error_type` valent `null` si la trace ne les a pas enregistrés.
`messages`	`system_instructions`, `input` et `output`. Chacun est une liste, vide (`[]`) lorsque le tour de conversation ne comporte aucun message de ce type.

Un tour de conversation qui se termine sans statut explicite arrive avec status.code défini sur UNSET. Traitez UNSET comme un tour de conversation terminé normalement, et ERROR comme le signal d’échec. Chaque message de input et output comporte role, content et finish_reason. content contient du texte brut, ou un tableau de parties encodé en JSON lorsque le message comporte du contenu structuré, comme des appels d’outil.

{
  "schema_version": 2,
  "scoring_target": {
    "type": "agent_turn",
    "schema_version": 1,
    "payload": {
      "event_type": "weave.genai.turn_ended",
      "project_id": "[YOUR-TEAM]/[YOUR-PROJECT]",
      "trace_id": "0af7651916cd43dd8448eb211c80319c",
      "span_id": "b7ad6b7169203331",
      "span_name": "invoke_agent sample-support-agent",
      "operation_name": "invoke_agent",
      "started_at": "2026-06-08T12:00:00+00:00",
      "ended_at": "2026-06-08T12:00:01+00:00",
      "conversation": {
        "id": "conversation-0001",
        "name": "Support session"
      },
      "agent": {
        "name": "sample-support-agent",
        "version": "2026-06-08",
        "description": "Answers support questions"
      },
      "status": {
        "code": "UNSET",
        "message": null,
        "error_type": null
      },
      "messages": {
        "system_instructions": [
          "Answer the user accurately and concisely."
        ],
        "input": [
          {
            "role": "user",
            "content": "What are your support hours?",
            "finish_reason": ""
          }
        ],
        "output": [
          {
            "role": "assistant",
            "content": "Our support team is available Monday through Friday, 9am to 5pm Eastern.",
            "finish_reason": "stop"
          }
        ]
      }
    }
  },
  "scoring_call_id": "018f8d6c-8d5f-7000-8000-000000000005",
  "scoring_trace_id": "018f8d6c-8d5f-7000-8000-000000000006",
  "monitor": {
    "name": "example_remote_scorer_agent_monitor",
    "version_digest": "monitor-version-digest"
  },
  "scorer": {
    "name": "example_remote_scorer",
    "ref": "weave:///[YOUR-TEAM]/[YOUR-PROJECT]/object/example_remote_scorer:scorer-version-digest",
    "config": {
      "example_threshold": 0.8
    }
  },
  "triggered_at": "2026-06-08T12:00:02+00:00"
}

Weave ajoute des champs facultatifs à une charge utile sans modifier la version de celle-ci. Weave ne supprime, ne renomme ou ne modifie la signification d’un champ qu’en publiant une nouvelle version de charge utile pour ce type, ou une nouvelle version d’enveloppe pour les modifications apportées à l’enveloppe. Tout nouveau type de cible intègre l’union V2 avec la version de charge utile 1.

Réponse

Renvoyez un code HTTP 200 avec un objet JSON comportant deux champs :

schema_version : entier égal à la valeur schema_version de la requête.
result : un objet de score, une liste d’objets de score ou un objet de la forme {"scores": [...]}.

Un objet de score comporte les champs suivants :

Champ	Requis	Description
`value`	Oui	Un tag, sous forme de chaîne de 36 caractères maximum, ou une note, sous forme de nombre compris entre `0.0` et `1.0`.
`reason`	Non	Une chaîne expliquant le score.
`confidence`	Non	Un nombre compris entre `0.0` et `1.0`.

Weave considère toute réponse autre que 200 comme un échec du scorer et n’enregistre aucun feedback pour cette tentative. Weave ne suit pas les redirections et les traite comme des échecs. Weave n’analyse pas le corps d’une réponse d’erreur. Renvoyez un code 4xx pour les requêtes que votre point de terminaison n’acceptera jamais et un code 5xx en cas de problème temporaire. Pour une requête portant sur un tour de conversation d’agent, la valeur de schema_version dans la réponse est 2. L’exemple suivant renvoie un seul objet de score :

{
  "schema_version": 2,
  "result": {
    "value": "concise",
    "reason": "72 characters.",
    "confidence": 0.9
  }
}

Weave normalise les tags et les justifications contenus dans le résultat avant de les stocker. Consultez Comment Weave normalise les scores.

Authentifier les requêtes provenant de Weave

Weave s’authentifie auprès de votre point de terminaison à l’aide d’un bearer token. La requête ne contient aucun identifiant d’authentification W&B. Le jeton atteste auprès de votre point de terminaison que la requête provient bien de Weave, et non l’inverse. Chaque RemoteScorer utilise l’un des deux modes suivants :

Mode	Ce que fait Weave	Ce que vous configurez
`oauth_client_credentials`	Demande un jeton à votre point de terminaison de jetons OAuth via le flux d’octroi client credentials, en transmettant l’ID client et le secret par authentification HTTP Basic (`client_secret_basic`), puis envoie ce jeton au point de terminaison de votre scorer.	L’URL du point de terminaison de jetons, l’ID client, le nom du secret contenant le secret client et, éventuellement, une portée.
`static_bearer`	Envoie un jeton fixe au point de terminaison de votre scorer.	Le nom du secret contenant le jeton.

Avant d’enregistrer le scorer, stockez le secret client ou le bearer token dans le magasin de secrets de l’équipe propriétaire du projet. La configuration du RemoteScorer ne contient que le nom du secret : le worker d’évaluation récupère sa valeur au moment de l’évaluation.

Créer un signal de scorer distant

Créez le signal dans l’interface Weave ou avec le SDK Python. Dans les deux cas, vous obtenez un RemoteScorer associé à un monitor qui cible weave.genai.turn_ended.

Interface Weave

Créez le signal depuis la vue Agents :

Dans la barre latérale du projet Weave, cliquez sur Agents.
Dans la barre d’onglets, cliquez sur Signals.
Cliquez sur New signal, puis sur Remote scorer.
Dans le volet latéral Remote scorer, Scored by est défini sur Remote scorer. Configurez les champs suivants :
- Scorer name : le nom affiché dans la colonne Scorer du tableau Signals. 128 caractères maximum.
- Scoring endpoint URL : l’URL à laquelle Weave envoie la requête POST.
- Authentication : Static bearer ou OAuth client credentials. Pour un bearer statique, sélectionnez ou saisissez le Bearer token secret name. Pour OAuth, saisissez le Token endpoint URL, le Client ID, le Client secret name et, éventuellement, le Scope. Les champs de secret attendent des noms de secrets d’équipe, et non leurs valeurs.
- Config (JSON, optional) : un objet JSON transmis à votre point de terminaison dans scorer.config.
- Only score turns matching (facultatif) : développez Advanced, puis ajoutez des filtres pour limiter les tours de conversation évalués par le signal, par exemple selon le nom de l’agent, la version de l’agent, le nom de l’opération, le nom de l’outil ou le code de statut. Pour évaluer tous les tours de conversation, laissez ce champ vide. Weave combine les filtres avec une logique AND.
- Sample rate (facultatif) : développez Advanced, puis définissez la proportion des tours de conversation correspondants que le signal évalue.
Cliquez sur Create signal.

Le formulaire du scorer distant ne comporte aucun champ de tag ni de score. C’est votre point de terminaison qui détermine ce qu’il renvoie, et le tableau Signals affiche les tags et les scores reçus. Dans la colonne Scorer, un signal de scorer distant est signalé par une icône de webhook.

SDK Python

Publiez un RemoteScorer, puis activez un Monitor qui le répertorie dans scorers et cible weave.genai.turn_ended dans op_names.

import weave
from weave.flow.monitor import Monitor
from weave.scorers.remote_scorer import RemoteScorer, StaticBearerAuthConfig

weave.init("[YOUR-TEAM]/[YOUR-PROJECT]")

scorer = RemoteScorer(
    name="policy_remote_scorer",
    endpoint_url="https://scoring.example.com/weave/score",
    config={"threshold": 0.9},  # Transmis à votre point de terminaison dans scorer.config
    auth_config=StaticBearerAuthConfig(
        mode="static_bearer",
        bearer_secret_name="WEAVE_REMOTE_SCORER_BEARER_TOKEN",
    ),
)
weave.publish(scorer, name="policy_remote_scorer")

monitor = Monitor(
    name="policy_remote_signal",
    scorers=[scorer],
    op_names=["weave.genai.turn_ended"],  # Évalue les tours de conversation terminés de l'agent
    sampling_rate=1.0,
)
monitor.activate()

Pour les identifiants client OAuth, transmettez plutôt un OAuthClientCredentialsConfig en tant que auth_config.

Exemple de code

Le répertoire examples/remote_scorer du dépôt weave constitue l’implémentation de référence de ce contrat et fait foi pour l’exemple de code. Dans cet exemple, un seul point de terminaison accepte à la fois les requêtes d’Appel V1, les requêtes d’Appel V2 et les requêtes de tour de conversation d’agent V2. Pour les tours de conversation d’agent, les fichiers concernés sont les suivants :

remote_scorer_app.py : une application FastAPI exposant GET /health et POST /score.
auth.py : une vérification du bearer token à partir de la variable d’environnement REMOTE_SCORER_DEV_BEARER_TOKEN, réservée au développement.
scoring_logic.py : désencapsule l’une ou l’autre enveloppe avec extract_scoring_target, puis évalue le dernier message de sortie du tour de conversation.
sample_request_v2_agent_turn.json : une requête complète de tour de conversation d’agent V2.
register_remote_scorer.py --agent-turn : publie un RemoteScorer et active un monitor pour les tours de conversation d’agent terminés.
trigger_test_agent_turn.py : journalise un tour de conversation avec weave.conversation.log_turn.

Pour exécuter le point de terminaison en local et lui envoyer une requête de tour de conversation d’agent V2 sans passer par Weave, démarrez l’application, puis envoyez l’exemple de requête :

python3 -m venv .venv && source .venv/bin/activate
python -m pip install -r requirements.txt
export REMOTE_SCORER_DEV_BEARER_TOKEN="dev-token"
uvicorn remote_scorer_app:app --host 127.0.0.1 --port 8000

curl -sS http://127.0.0.1:8000/score \
  -H "Authorization: Bearer dev-token" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: local-contract-check" \
  -H "X-Correlation-ID: local-contract-check" \
  -H "X-Weave-Schema-Version: 2" \
  --data @sample_request_v2_agent_turn.json

Cet exemple nécessite Weave 0.53.0 ou une version ultérieure. Un run local ne vérifie que le contrat.

Tester le signal

Avant de procéder au test, déployez le point de terminaison sur une URL HTTPS figurant parmi les hôtes autorisés, puis enregistrez-le. Journalisez un tour de conversation terminé, puis consultez l’onglet Signals. Le scoring étant asynchrone, le résultat s’affiche au bout de quelques instants.

import uuid

from opentelemetry import trace

import weave
from weave.conversation import Message, log_turn

weave.init("[YOUR-TEAM]/[YOUR-PROJECT]")

result = log_turn(
    conversation_id=f"sample-{uuid.uuid4().hex}",
    agent_name="sample-support-agent",
    system_instructions=["Answer the user accurately and concisely."],
    messages=[Message.user("What are your support hours?")],
    output_messages=[
        Message.assistant(
            "Our support team is available Monday through Friday, 9am to 5pm Eastern."
        )
    ],
)

# weave.init exporte les spans depuis un thread d'arrière-plan. Forcez leur vidage avant la fin d'un script court.
trace.get_tracer_provider().force_flush(30_000)
print(result.conversation_id, result.trace_ids)

Votre point de terminaison reçoit une requête V2 dont le champ scoring_target.type est défini sur agent_turn, et Weave enregistre le résultat sous forme de feedback associé à ce tour de conversation.

Résolution des problèmes

Symptôme	Points à vérifier
Remote scorer n’apparaît pas dans le volet latéral New signal	L’évaluation à distance est activée dans les paramètres Remote scoring de l’organisation propriétaire, ou par l’administrateur de votre déploiement.
L’URL du point de terminaison est rejetée	L’hôte du scorer, ainsi que l’hôte du point de terminaison de jeton pour OAuth, figurent parmi les hôtes autorisés. Vérifiez qu’il n’y a pas de port non concordant, d’URL non HTTPS, ni d’adresse privée ou interne.
Le point de terminaison renvoie `401` ou `403`	Le nom du secret, les identifiants d’authentification du client OAuth, l’audience et la portée, ainsi que la validation des jetons par votre point de terminaison.
Le point de terminaison renvoie `400` pour les tours de conversation d’agent	Le point de terminaison vérifie la version de l’enveloppe et accepte `scoring_target.type` `agent_turn` avec la version de charge utile `1`.
Aucun résultat n’apparaît dans l’onglet Signals	Le scoring est asynchrone. Vérifiez que le tour de conversation correspond aux filtres et au taux d’échantillonnage du signal, et que le span racine du tour est terminé.
Le tour de conversation correspond au signal, mais aucun tag ni aucun score n’apparaît	Weave n’enregistre rien lorsqu’une tentative de scoring échoue. Recherchez l’en-tête `X-Correlation-ID` dans les journaux de requêtes de votre point de terminaison. Si le point de terminaison n’a reçu aucune requête, l’URL ne respecte pas les règles d’hôtes autorisés ou le secret n’a pas pu être résolu. S’il a reçu une requête, la réponse n’a pas passé la validation.
Aucun résultat après une réponse `200`	Le champ `schema_version` de la réponse vaut `2`, et `result` utilise l’une des trois structures prévues.

Premiers pas

Guides

Guides pratiques

Référence

Détails et assistance

Évaluer les tours de conversation d’un agent avec un scorer distant

Fonctionnement de l’évaluation des tours de conversation d’un agent

Activer l’évaluation à distance

Créer le point de terminaison du scorer

Requête

Réponse

Authentifier les requêtes provenant de Weave

Créer un signal de scorer distant

Interface Weave

SDK Python

Exemple de code

Tester le signal

Résolution des problèmes

​Fonctionnement de l’évaluation des tours de conversation d’un agent

​Activer l’évaluation à distance

​Créer le point de terminaison du scorer

​Requête

​Réponse

​Authentifier les requêtes provenant de Weave

​Créer un signal de scorer distant

​Interface Weave

​SDK Python

​Exemple de code

​Tester le signal

​Résolution des problèmes

Fonctionnement de l’évaluation des tours de conversation d’un agent

Activer l’évaluation à distance

Créer le point de terminaison du scorer

Requête

Réponse

Authentifier les requêtes provenant de Weave

Créer un signal de scorer distant

Interface Weave

SDK Python

Exemple de code

Tester le signal

Résolution des problèmes