> ## Documentation Index
> Fetch the complete documentation index at: https://docs.truthlocks.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Intégrations MAIP

> Connectez vos agents IA aux outils et plateformes que votre équipe utilise déjà.

# Intégrations MAIP

Le protocole d'identité d'agent machine (MAIP) est livré avec des intégrations qui apportent l'identité de l'agent, les reçus et la notation de confiance à vos flux de travail existants. Les preuves locales, la soumission de reçus hébergés et la vérification de signature sont des opérations distinctes. Configurez et testez l'intégration que vous utilisez ; l'installation seule ne crée pas une piste d'audit complète.

> [!NOTE]
>
> **Prérequis :** Vous avez besoin d'un compte Truthlocks avec une clé API et au moins un agent enregistré. Consultez le [guide d'identité machine](https://docs.truthlocks.com/fr/guides/machine-identity.md) pour enregistrer votre premier agent.

> [!TIP]
>
> Parcourez les intégrations disponibles sur le [Hub d'intégrations](https://truthlocks.com/resources/integrations). Les liens sont regroupés par SDK, framework d'IA, éditeur et outil de collaboration.

## Outils de développement

### Extension VS Code

Un panneau latéral pour parcourir les reçus, générer des reçus depuis votre éditeur et afficher les données de confiance. Installez-le depuis le [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=truthlocks.maip-vscode).

**Ce que cela fait :**

* Parcourir et rechercher les reçus MAIP depuis la barre latérale
* Générer des reçus pour les modifications de code directement depuis l'éditeur
* Afficher les scores de confiance des agents et les chaînes de reçus

**Installation :**

1. Ouvrez VS Code et allez dans la vue Extensions (`Ctrl+Shift+X` / `Cmd+Shift+X`).
2. Recherchez « Truthlocks MAIP ».
3. Cliquez sur **Installer**.

Alternativement, installez depuis la ligne de commande :

```bash theme={null}
code --install-extension truthlocks.maip-vscode
```

Après l'installation, ouvrez le panneau latéral MAIP et entrez votre clé API et votre ID d'agent pour vous connecter.

### Plugin JetBrains

Intégration MAIP pour IntelliJ, PyCharm et WebStorm avec les mêmes capacités de navigation et de génération de reçus que l'extension VS Code.

### Plugin Neovim

Installez le plugin `truthlocks/maip.nvim` publié, avec curl disponible sur votre PATH:

```lua theme={null}
-- lazy.nvim
{ "truthlocks/maip.nvim", tag = "v1.1.0", main = "maip",
  opts = {
    api_url = "https://sandbox-api.truthlocks.com/v1",
    api_key = vim.env.MAIP_API_KEY or "",
    agent_id = vim.env.MAIP_AGENT_ID or "",
    auto_receipt_on_commit = false,
    telescope = false,
  } }
```

Utilisez `:MAIPListAgents`, `:MAIPCreateReceipt`, `:MAIPListReceipts`,
`:MAIPVerifyReceipt`, `:MAIPShowTrust` et `:MAIPDashboard`. Les métadonnées du reçu sont
pas une signature vérifiée. Les reçus de commit automatiques sont optionnels et observent les
événements de commit terminés ; il n'y a pas d'option `auto_receipt` de sauvegarde dans cette version.
Consultez le [README versionné](https://github.com/truthlocks/maip.nvim) pour Telescope
configuration et les limites actuelles des tests interactifs.

### Serveur MCP

Installez l'exécutable sur la machine exécutant votre hôte MCP:

```sh theme={null}
npm install --global @truthlocks/maip-mcp-server@1.2.4
```

```json theme={null}
{
  "mcpServers": {
    "truthlocks": {
      "command": "maip-mcp-server",
      "env": {
        "MAIP_API_URL": "https://sandbox-api.truthlocks.com/v1",
        "MAIP_API_KEY": "REPLACE_WITH_WORKSPACE_TEST_KEY",
        "MAIP_TIMEOUT_MS": "30000",
        "MAIP_MAX_RETRIES": "3"
      }
    }
  }
}
```

Fournissez les identifiants via la configuration sécurisée de l'hôte. Utilisez une clé et un agent
du même environnement. Demandez à l'hôte de lister les outils disponibles, puis utilisez
`maip_list_agents`, `maip_list_receipts` et `maip_verify_receipt`. Une signature positive
le résultat nécessite `valid: true`, `signature_verified: true` et `verdict: "VALID"`.
La vérification de la transparence est un résultat distinct. Les écritures ne sont pas automatiquement réessayées.

## Collaboration d'équipe

Les intégrations Slack, Linear et Notion nécessitent leur propre application/espace de travail réel
informations d'identification en plus de l'authentification Truthlocks. Leur processus complet de fournisseur à reçu
l'acceptation est toujours en attente. Ne traitez pas la disponibilité de la source, les tests locaux ou un
Clé API Truthlocks comme preuve qu'un espace de travail externe est connecté.

Consultez le fichier README du package source pour les permissions et la configuration du fournisseur :
[Slack](https://github.com/truthlocks/truthlock/tree/main/packages/maip-slack),
[Linéaire](https://github.com/truthlocks/truthlock/tree/main/packages/maip-linear),
[Notion](https://github.com/truthlocks/truthlock/tree/main/packages/maip-notion).
Utilisez un espace de travail de test dédié avant d'activer le traitement des événements réels.

### Configuration et validation Slack

Slack est une installation source, pas un package npm `@truthlocks/maip-slack` publié.
Son authentification de bot et une soumission de message de test autorisée ont été validées par le fournisseur
vérifications. Les commandes slash complètes pour les utilisateurs personnels et les flux de travail d'événements hébergés restent en cours de développement.
validation. Suivez le [README de Slack](https://github.com/truthlocks/truthlock/tree/main/packages/maip-slack)
pour la construction examinée et tous les paramètres requis.

Liez l'application à `SLACK_TEAM_ID` et aux `SLACK_ALLOWED_USER_IDS` personnels explicites.
Utilisez `MAIP_AGENT_ID` d'un agent Truthlocks enregistré existant pour la création ;
un ID de membre Slack n'est pas une identité machine. Fournissez une clé de sandbox et
`https://sandbox-api.truthlocks.com/v1` pendant l'évaluation. Les commandes sont enregistrées
dans les paramètres de l'application Slack. Les modes HTTP et Socket fournissent tous deux `/webhook/maip`, mais
l'hébergement de l'écouteur n'abonne pas automatiquement les événements Truthlocks à celui-ci.
Les approbations de délégation restent en examen dans la Console authentifiée. Protection contre la relecture locale
est local au processus ; la livraison en production nécessite un suivi amont durable.

### Configuration et validation Notion

Notion est un package source privé, pas une installation npm. Acceptation QA réelle
a créé une page enfant et des schémas de base de données, a inséré un reçu d'espace de travail existant,
a répété la synchronisation sans dupliquer cette page, et a vérifié la relecture du fournisseur.
L'automatisation hébergée continue et la récupération durable sont toujours en cours de validation.

Connectez uniquement la page souhaitée en utilisant le menu **••• → Connexions** de Notion. Suivez le
[README Notion](https://github.com/truthlocks/truthlock/tree/main/packages/maip-notion)
pour initialiser les bases de données une fois et réutiliser leurs ID. Utilisez `WEBHOOK_SECRET` avec le
contrat HMAC/horodatage versionné ; les requêtes non signées sont rejetées. Statut du reçu
est une métadonnée, donc un reçu complété ne vérifie pas automatiquement le Notion
case **Vérifié**. Utilisez une vérification de signature explicite séparément.

## CI/CD

Les entrées de l'action MAIP sont `maip-api-url`, `maip-api-key` et `maip-agent-id`.
Les anciens noms `api-key` et `agent-id` ne sont pas des entrées déclarées. Pour un examen
extraction de la source avec son `dist/index.js` intégré, un flux de travail QA explicitement déclenché
peut utiliser cette étape :

```yaml theme={null}
- uses: ./packages/maip-github-action
  with:
    maip-api-url: https://sandbox-api.truthlocks.com/v1
    maip-api-key: ${{ secrets.TRUTHLOCKS_API_KEY }}
    maip-agent-id: ${{ vars.TRUTHLOCKS_AGENT_ID }}
    mode: receipt
    event-type: commit
    create-check: 'false'
    post-comment: 'false'
```

Ceci est un chemin d'action local après le checkout et la construction, et non un Marketplace non vérifié
étiquette. Épinglez les versions révisées lors de la distribution de l'action. Vérifiez/commentez la publication
nécessite des permissions GitHub délibérées et une acceptation distincte ; n'exposez jamais de secrets
aux workflows des forks non fiables. Voir le [README de l'action](https://github.com/truthlocks/truthlock/tree/main/packages/maip-github-action).

## Connecteurs de modèles d'IA

Les wrappers Python capturent les événements émis via l'intégration configurée. Les hachages locaux ne sont pas des signatures de serveur. Les identifiants du fournisseur, les identifiants Truthlocks et la soumission hébergée sont configurés séparément ; inspectez les métadonnées que vous envoyez et ne supposez pas que le hachage supprime les obligations de confidentialité.

### Cadres pris en charge

| Cadre | Installer |
| :- | :- |
| LangChain | `pip install truthlocks-langchain` |
| LlamaIndex | `pip install truthlocks-llamaindex` |
| CrewAI | `pip install truthlocks-crewai` |
| AutoGen | `pip install truthlocks-autogen` |
| OpenAI | `pip install truthlocks-openai` |
| Anthropic | `pip install truthlocks-anthropic` |
| AWS Bedrock | `pip install truthlocks-bedrock` |

**Exemple LangChain local complet (aucune requête hébergée) :**

```python theme={null}
from langchain_core.runnables import RunnableLambda
from truthlocks_langchain import MAIPRunnableWrapper
from maip_ai_connectors.config import MAIPConfig

chain = RunnableLambda(lambda value: value.upper())
wrapped = MAIPRunnableWrapper(chain, config=MAIPConfig(auto_receipt=False))
print(wrapped.invoke("hello"))
receipts = wrapped.get_receipts()
print(receipts[0].payload_hash)
wrapped.clear_receipts()
```

`payload_hash` décrit les preuves locales. Pour la soumission hébergée, utilisez `MAIPClient.create_receipt`
et vérifiez le `receipt_id` du serveur retourné ; le [LangChain README](https://github.com/truthlocks/truthlock/tree/main/packages/truthlocks-langchain)
contient l'exemple de soumission asynchrone. Pour les hooks automatiques asynchrones, vider et
fermer le wrapper et inspecter les résultats de la soumission avant l'arrêt. Les appels en dehors du
wrapper configuré ne sont pas observés.

## Pipelines de données et de ML

### Connecteur Kafka

Le connecteur Go soumet les empreintes de message comme reçus MAIP `data.attestation`
à l'aide d'un agent existant. Son client HTTP utilise `/v1/agent-receipts`, préserve les partiels
les résultats des lots, et nécessite une signature confirmée pour une vérification réussie.

Installez `github.com/truthlocks/kafka-maip-connector@v0.1.0` avec `go get`.
Voir l'[exemple de publication et de complétion](https://github.com/truthlocks/kafka-maip-connector/releases/tag/v0.1.0).
La clé API sélectionne l'espace de travail et l'environnement ; un ID de locataire fourni par l'appelant le fait
ne remplace pas l'autorisation. Les octets de message et les clés de message brutes ne sont pas téléchargés.

Les wrappers producteur/consommateur mettent en mémoire tampon les reçus. Livraison et réception du courtier
la livraison sont des opérations distinctes ; une écriture Kafka réussie ne garantit pas une
le reçu a été conservé. La livraison d'audit requise nécessite une boîte d'envoi d'application durable
et une gestion explicite des échecs. Consultez les preuves de publication avant toute utilisation en production.

### Diffusion d'événements

Installez [Go event-stream v0.1.0](https://github.com/truthlocks/maip-event-stream/releases/tag/v0.1.0):

```sh theme={null}
go get github.com/truthlocks/maip-event-stream@v0.1.0
```

La bibliothèque comprend un client Redis concret et des interfaces d'adaptateur pour NATS
JetStream, EventBridge et Kinesis. Les consommateurs Redis qui se reconnectent scannent leurs propres
entrées en attente avant les nouveaux messages ; le traitement échoué reste non acquitté.
Gardez les noms de consommateurs stables lors des redémarrages. Revendiquer le pending d'un autre consommateur
les entrées nécessitent toujours un processus de récupération explicite. L'artefact publié a passé
un test isolé de redémarrage/acquittement de Redis réel et la suite complète de tests de concurrence Go.
D'autres adaptateurs backend nécessitent des implémentations client réelles et authentifiées. Ces adaptateurs
enveloppes d'événements de transport ; elles ne créent ni ne vérifient automatiquement les signatures MAIP.
La génération de reçus Kafka est un connecteur distinct, décrit ci-dessus.

> [!WARNING]
>
> La passerelle autonome n'est pas prête pour le déploiement : ses fabriques de clients backend
> ne sont pas câblés, et il refuse maintenant de démarrer plutôt que de signaler des actions non effectuées
> publications comme acceptées. Il n'y a pas de `truthlocks_streaming.StreamingGateway` publié
> API Python correspondant à l'exemple plus ancien sur cette page.

La déduplication utilise désormais un cache exact borné des identités d'événements confirmées, délimité
au locataire et à la source. Les publications échouées ne sont pas mises en cache. Les tentatives sont par défaut à zéro ;
les tentatives explicites fournissent une livraison au moins une fois, pas des garanties exactement une fois.
Le middleware de lot gère un événement à la fois, il ne peut donc pas deviner les éléments échoués
des totaux agrégés. L'éviction du cache et le redémarrage du processus peuvent permettre des doublons.

Le validateur de reçu vérifie la structure et les liens de hachage locaux ; ce n'est pas une signature
vérificateur. Maintenez le routage authentifié, la rétention durable et la validation cryptographique
dans la conception de votre application.

### MLflow, DVC et Delta Lake

Installez `mlflow-maip`, `dvc-maip` ou `delta-lake-maip` pour les métadonnées correspondantes
constructeurs. Ces paquets produisent des preuves structurées locales ; l'installation de l'un d'eux ne
faire de chaque opération de framework un reçu hébergé signé. Il n'y a pas de support
`truthlocks_mlflow.TruthlocksPlugin.enable` API correspondant à l'exemple plus ancien.

Utilisez les exemples locaux et hébergés complets dans les README sources :
[MLflow](https://github.com/truthlocks/truthlock/tree/main/packages/mlflow-maip),
[DVC](https://github.com/truthlocks/truthlock/tree/main/packages/dvc-maip),
[Delta Lake](https://github.com/truthlocks/truthlock/tree/main/packages/delta-lake-maip).
Les métadonnées du fournisseur et les URI d'artefacts ne vérifient pas indépendamment les octets d'artefacts ou
prouver qu'une opération externe a eu lieu. La vérification de signature hébergée ne
établir l'inclusion dans le journal de transparence à moins que cette vérification distincte ne réussisse.

## Docker

Les fichiers source du conteneur n'établissent pas qu'une image publique a été publiée ou
acceptation passée. Les images `truthlocks/*:latest` précédemment listées et combinées
L'exemple de composition n'a pas été vérifié comme un déploiement fonctionnel et n'est pas un
démarrage rapide pris en charge. N'inférez pas la disponibilité des images à partir de ces noms historiques.

Utilisez la version du package publiée et son README pour chaque intégration. Si vous construisez
un conteneur à partir d'une source examinée, épinglez cette révision et les dépendances, fournissez les secrets
via votre runtime, et testez la connexion réelle du fournisseur. Slack en plus
nécessite ses véritables identifiants d'application ; une clé API Truthlocks seule est insuffisante.
La passerelle de flux d'événements autonome reste indisponible comme décrit ci-dessus.

## Prochaines étapes

> [card] [Identité machine](https://docs.truthlocks.com/guides/machine-identity.md)
>
> Enregistrez votre premier agent et comprenez le protocole MAIP.

> [card] [Autorisation de l'agent](https://docs.truthlocks.com/guides/agent-authorization.md)
>
> Configurez les portées, les sessions et l'accès aux outils pour vos agents.

> [card] [Téléchargements](https://truthlocks.com/resources/downloads)
>
> Trouvez les versions publiées de CLI, SDK et IDE et leurs instructions d'installation.

> [card] [Centre d'intégrations](https://truthlocks.com/resources/integrations)
>
> Parcourir toutes les intégrations par catégorie.

### Linéaire

Authentification réelle du fournisseur, recherche de problème SDK et un commentaire de reçu avec relecture
passé dans un problème QA explicitement autorisé. Cela n'établit pas de webhook hébergé
création de reçu ou synchronisation continue. L'écouteur source vérifie Linear's
Signature HMAC et horodatage signé, et restreint les événements à l'organisation configurée
et les ID d'équipe. L'automatisation des jalons de projet reste indisponible plutôt que d'émettre
preuves estimées. Voir la [configuration et les limites de Linear](https://github.com/truthlocks/truthlock/tree/main/packages/maip-linear#readme).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.