> Discover all available pages from the documentation index: https://mastra.zisheng.pro/fr/llms.txt

# Exporter Arthur

[Arthur](https://arthur.ai/) fournit une plateforme d’observabilité et d’évaluation des applications d’IA par l’intermédiaire d’[Arthur Engine](https://github.com/arthur-ai/arthur-engine), qui est open source. L’exporter Arthur envoie les traces en appliquant les conventions sémantiques OpenTelemetry et [OpenInference](https://github.com/Arize-ai/openinference/tree/main/spec).

## Installation

**npm**:

```bash
npm install @mastra/arthur@latest
```

**pnpm**:

```bash
pnpm add @mastra/arthur@latest
```

**Yarn**:

```bash
yarn add @mastra/arthur@latest
```

**Bun**:

```bash
bun add @mastra/arthur@latest
```

## Configuration

### Prérequis

1. **Instance Arthur Engine** : suivez le [guide de déploiement avec Docker Compose](https://docs.arthur.ai/docs/arthur-genai-engine-docker-compose-deployment-guide) pour démarrer Arthur Engine
2. **Clé API** : [générez une clé API](https://docs.arthur.ai/docs/api-keys-management) depuis l’interface Arthur Engine à l’adresse `http://localhost:3030`
3. **ID de tâche** (facultatif) : [créez une tâche](https://docs.arthur.ai/docs/create-a-task) pour diriger les traces vers une tâche précise

### Routage vers les tâches

Arthur Engine associe les traces aux tâches de deux manières :

- **Par nom de service** : définissez `serviceName` dans la configuration de l’observabilité. Arthur Engine dirige automatiquement les traces vers la tâche portant ce nom et la crée si nécessaire.
- **Par ID de tâche** : transmettez un `taskId` existant à l’exporter pour envoyer directement les traces à une tâche précise.

Lorsque les deux sont fournis, `taskId` est prioritaire.

### Variables d’environnement

```bash
# Required
ARTHUR_API_KEY=your-api-key
ARTHUR_BASE_URL=http://localhost:3030

# Optional - route traces to a pre-existing task by ID
ARTHUR_TASK_ID=your-task-id
```

### Configuration automatique

Une fois les variables d’environnement définies, utilisez l’exporter sans configuration :

```typescript
import { Mastra } from '@mastra/core'
import { Observability } from '@mastra/observability'
import { ArthurExporter } from '@mastra/arthur'

export const mastra = new Mastra({
  observability: new Observability({
    configs: {
      arthur: {
        serviceName: 'my-service',
        exporters: [new ArthurExporter()],
      },
    },
  }),
})
```

### Configuration explicite

Vous pouvez également transmettre les identifiants directement ; ils prévalent sur les variables d’environnement :

```typescript
import { Mastra } from '@mastra/core'
import { Observability } from '@mastra/observability'
import { ArthurExporter } from '@mastra/arthur'

export const mastra = new Mastra({
  observability: new Observability({
    configs: {
      arthur: {
        serviceName: 'my-service',
        exporters: [
          new ArthurExporter({
            apiKey: process.env.ARTHUR_API_KEY!,
            endpoint: process.env.ARTHUR_BASE_URL!,
            taskId: process.env.ARTHUR_TASK_ID,
          }),
        ],
      },
    },
  }),
})
```

## Options de configuration

### Configuration complète

```typescript
new ArthurExporter({
  // Arthur Configuration
  apiKey: 'your-api-key', // Required
  endpoint: 'http://localhost:3030', // Required
  taskId: 'your-task-id', // Optional

  // Optional OTLP settings
  headers: {
    'x-custom-header': 'value', // Additional headers for OTLP requests
  },

  // Debug and performance tuning
  logLevel: 'debug', // Logging: debug | info | warn | error
  batchSize: 512, // Batch size before exporting spans
  timeout: 30000, // Timeout in ms before exporting spans

  // Custom resource attributes
  resourceAttributes: {
    'deployment.environment': process.env.NODE_ENV,
    'service.version': process.env.APP_VERSION,
  },
})
```

### Métadonnées personnalisées

Les attributs de span non réservés sont sérialisés dans la charge utile `metadata` d’OpenInference et apparaissent dans Arthur. Vous pouvez les ajouter via `tracingOptions.metadata` :

```ts
await agent.generate(input, {
  tracingOptions: {
    metadata: {
      companyId: 'acme-co',
      tier: 'enterprise',
    },
  },
})
```

Les champs réservés tels que `input`, `output`, `sessionId`, les ID de thread ou d’utilisateur et les ID OpenInference sont automatiquement exclus.

## Conventions sémantiques OpenInference

Cet exporter implémente les [conventions sémantiques OpenInference](https://github.com/Arize-ai/openinference/tree/main/spec) pour les applications d’IA générative, ce qui fournit une structure de traces standardisée entre les différentes plateformes d’observabilité.

## Pages connexes

- [Présentation du tracing](https://mastra.zisheng.pro/fr/docs/observability/tracing/overview)
- [Référence de ArthurExporter](https://mastra.zisheng.pro/fr/reference/observability/tracing/exporters/arthur)
- [Documentation Arthur Engine](https://docs.arthur.ai/)
- [Dépôt Arthur Engine](https://github.com/arthur-ai/arthur-engine)
- [Spécification OpenInference](https://github.com/Arize-ai/openinference/tree/main/spec)