MAIP integrations

Connect your AI agents to the tools and platforms your team already uses.

MAIP integrations

The Machine Agent Identity Protocol (MAIP) ships with integrations that bring agent identity, receipts, and trust scoring into your existing workflows. Each integration generates cryptographic receipts automatically, so every action has a verifiable audit trail.

Prerequisites: You need a Truthlocks account with an API key and at least one registered agent. See the machine identity guide to register your first agent.

Browse and filter all available integrations on the Integrations Hub. You can search by category, framework, or platform to find the right connector for your stack.

Developer tools

VS Code extension

A sidebar panel for browsing receipts, generating receipts from your editor, and viewing trust data. Install it from the Visual Studio Marketplace.

What it does:

• Browse and search MAIP receipts from the sidebar
• Generate receipts for code changes directly from the editor
• View agent trust scores and receipt chains

Installation:

1. Open VS Code and go to the Extensions view (Ctrl+Shift+X / Cmd+Shift+X).
2. Search for “Truthlocks MAIP”.
3. Click Install.

Alternatively, install from the command line:

code --install-extension truthlocks.maip-vscode

After installing, open the MAIP sidebar panel and enter your API key and agent ID to connect.

JetBrains plugin

MAIP integration for IntelliJ, PyCharm, and WebStorm with the same receipt browsing and generation capabilities as the VS Code extension.

Neovim plugin

A Lua-native plugin for Neovim that integrates MAIP receipts, agent management, and trust scores into your editor. Includes Telescope integration for searching receipts and a statusline component for displaying agent status.

Setup with lazy.nvim:

{
  "truthlocks/maip-neovim",
  config = function()
    require("maip").setup({
      api_key = vim.env.TRUTHLOCKS_API_KEY,
      agent_id = "maip-agent:01JXXXX",
    })
  end,
}

Available commands:

Command	Description
:MaipReceipt	Create a receipt for the current buffer
:MaipReceipts	List recent receipts in a split
:MaipTrust	Show the trust score for the configured agent
:MaipAgent	Display agent status and metadata
:MaipSearch	Open the Telescope receipt picker

Telescope integration:

Use :MaipSearch or call require("telescope").extensions.maip.receipts() to open a fuzzy-finder over your receipts. Results show the receipt ID, type, and timestamp. Press <CR> to view full details in a split buffer.

Statusline component:

Add the agent trust score to your statusline by calling the provider function. For example, with lualine:

require("lualine").setup({
  sections = {
    lualine_x = {
      { require("maip").statusline, cond = require("maip").is_active },
    },
  },
})

The component displays the agent ID and current trust score, and updates automatically when you create receipts or refresh trust data.

Auto-receipt on save:

Enable automatic receipt generation whenever you write a buffer by setting auto_receipt = true in your setup call:

require("maip").setup({
  api_key = vim.env.TRUTHLOCKS_API_KEY,
  agent_id = "maip-agent:01JXXXX",
  auto_receipt = true,
})

MCP Server

A Model Context Protocol server that exposes 20 tools, 4 resources, and 3 prompts for AI assistants to interact with the MAIP platform. Use this to give your AI coding assistants direct access to agent registration, receipt generation, and trust score queries.

Example configuration:

{
  "mcpServers": {
    "truthlocks-maip": {
      "command": "truthlocks-mcp",
      "env": {
        "TRUTHLOCKS_API_KEY": "tl_live_your_api_key"
      }
    }
  }
}

Team collaboration

Slack

Slash commands let your team query receipts, trust scores, and agent status directly from Slack. Interactive Block Kit layouts display receipt details, risk summaries, and dashboards inline.

Available commands:

Command	Description
/maip-receipt <id>	Look up a receipt by ID and display its details
/maip-trust <agent_id>	Show the current trust score for an agent
/maip-agent <agent_id>	Display agent status, scopes, and metadata
/maip-help	List all available MAIP commands

Linear

Issue and comment events in Linear automatically create MAIP receipts. You can verify receipts and post trust scores as comments, with bidirectional sync between Linear and the MAIP platform.

Notion

Automatically creates Receipts, Agents, and Trust Scores databases in your Notion workspace. Syncs receipts incrementally, generates audit report pages, and updates Notion in real time via webhooks.

CI/CD

GitHub Action

Automatically generate MAIP receipts for commits, pull requests, releases, CI runs, and build artifacts. Verification results appear as GitHub Check Runs with trust score badges on your PRs.

Example workflow:

name: MAIP receipts
on:
  push:
    branches: [main]
  pull_request:

jobs:
  maip:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: truthlocks/maip-action@v1
        with:
          api-key: ${{ secrets.TRUTHLOCKS_API_KEY }}
          agent-id: ${{ secrets.MAIP_AGENT_ID }}

AI model connectors

Python connectors that generate a MAIP receipt for every AI model call, capturing token counts, cost estimates, and SHA-256 content hashes. Prompts and responses are hashed — not stored — for privacy.

Supported frameworks

Framework	Install
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

Example with LangChain:

from truthlocks_langchain import TruthlocksCallback

callback = TruthlocksCallback(
    api_key="tl_live_your_api_key",
    agent_id="maip-agent:01JXXXX"
)

# Every LLM call now generates a MAIP receipt
chain.invoke({"input": "Summarize this document"}, config={"callbacks": [callback]})

Data and ML pipelines

Kafka connector

Go middleware that generates MAIP data-flow receipts for Kafka messages. Supports batched flushing and exposes operational metrics for monitoring.

Event streaming

A multi-backend event streaming gateway that generates MAIP receipts for messages flowing through your data pipelines. Use it when you need receipt-backed audit trails for event-driven architectures.

Supported backends:

Backend	Description
Kafka	Apache Kafka message receipts with batched flushing
AWS EventBridge	Publish and subscribe to EventBridge events with receipts
AWS Kinesis	Kinesis stream records with receipt generation
NATS	NATS messaging with receipt-backed delivery
Redis Streams	Redis Streams pub/sub with automatic receipts

Each backend includes built-in deduplication, retry middleware, and operational metrics. Configure the gateway to connect to one or more backends and every message automatically gets a MAIP data-flow receipt.

Example configuration:

from truthlocks_streaming import StreamingGateway

gateway = StreamingGateway(
    api_key="tl_live_your_api_key",
    agent_id="maip-agent:01JXXXX",
    backends=[
        {
            "type": "kafka",
            "brokers": ["localhost:9092"],
            "topic": "events",
            "batch_size": 100,
        },
        {
            "type": "redis",
            "url": "redis://localhost:6379",
            "stream": "receipts",
        },
    ],
)

# Every message published through the gateway generates a MAIP data-flow receipt
gateway.publish("events", {"action": "user.login", "user_id": "u_123"})

You can run multiple backends simultaneously. The gateway deduplicates messages across backends using content hashes, retries failed deliveries with exponential backoff, and exposes Prometheus-compatible metrics at /metrics.

If you only need Kafka receipts without the multi-backend gateway, use the standalone Kafka connector instead.

MLflow plugin

Python plugin that generates cryptographic receipts for every MLflow model run, providing provenance proof for your ML experiments.

import mlflow
from truthlocks_mlflow import TruthlocksPlugin

mlflow.set_tracking_uri("http://localhost:5000")
TruthlocksPlugin.enable(api_key="tl_live_your_api_key", agent_id="maip-agent:01JXXXX")

with mlflow.start_run():
    # Your training code — a receipt is created automatically
    mlflow.log_metric("accuracy", 0.95)

DVC plugin

Python plugin for creating MAIP receipts on DVC data versioning operations. Each dvc push or dvc pull generates a receipt linking the data version to your agent identity.

Delta Lake plugin

Python plugin for generating receipts on Delta Lake table operations. Tracks table writes, schema changes, and compaction events with cryptographic provenance.

Docker

You can run MAIP integration services as Docker containers instead of installing them locally. Official images are available for the CLI, MCP Server, event streaming gateway, and Slack integration.

Environment variables

Every MAIP container requires at least the two core variables below. Some services accept additional configuration.

Variable	Required	Description
TRUTHLOCKS_API_KEY	Yes	Your Truthlocks API key
MAIP_AGENT_ID	Yes	The agent ID to associate with this service
SLACK_BOT_TOKEN	Slack only	Bot token for the Slack integration
SLACK_SIGNING_SECRET	Slack only	Signing secret for verifying Slack requests

Run an individual service

Pull and run any MAIP service image directly. Pass your API key and agent ID as environment variables.

docker run -e TRUTHLOCKS_API_KEY=tl_live_your_api_key \
  -e MAIP_AGENT_ID=maip-agent:01JXXXX \
  truthlocks/maip-mcp-server:latest

Available images:

Image	Description
truthlocks/cli	The Truthlocks CLI for minting attestations, managing issuers, and generating receipts
truthlocks/maip-mcp-server	The MCP Server exposing 20 tools for AI assistants
truthlocks/maip-event-stream	The event streaming gateway for receipt-backed data pipelines
truthlocks/maip-slack	The Slack integration for querying receipts and trust scores from Slack

Run the full MAIP stack

Use Docker Compose to start all MAIP services together. This is the fastest way to get started with self-hosted MAIP integrations for local development and testing.

Create a docker-compose.yml file:

version: "3.8"
services:
  cli:
    image: truthlocks/cli:latest
    environment:
      TRUTHLOCKS_API_KEY: ${TRUTHLOCKS_API_KEY}
      MAIP_AGENT_ID: ${MAIP_AGENT_ID}

  mcp-server:
    image: truthlocks/maip-mcp-server:latest
    environment:
      TRUTHLOCKS_API_KEY: ${TRUTHLOCKS_API_KEY}
      MAIP_AGENT_ID: ${MAIP_AGENT_ID}

  event-stream:
    image: truthlocks/maip-event-stream:latest
    environment:
      TRUTHLOCKS_API_KEY: ${TRUTHLOCKS_API_KEY}
      MAIP_AGENT_ID: ${MAIP_AGENT_ID}

  slack:
    image: truthlocks/maip-slack:latest
    environment:
      TRUTHLOCKS_API_KEY: ${TRUTHLOCKS_API_KEY}
      MAIP_AGENT_ID: ${MAIP_AGENT_ID}
      SLACK_BOT_TOKEN: ${SLACK_BOT_TOKEN}
      SLACK_SIGNING_SECRET: ${SLACK_SIGNING_SECRET}

Then start the stack:

export TRUTHLOCKS_API_KEY=tl_live_your_api_key
export MAIP_AGENT_ID=maip-agent:01JXXXX
docker compose up

You can also run a subset of services by specifying them explicitly — for example, docker compose up mcp-server event-stream to start only those two.

Next steps

Machine identity

Register your first agent and understand the MAIP protocol.

Agent authorization

Configure scopes, sessions, and tool access for your agents.

Downloads

Get the CLI, SDKs, IDE plugins, and Docker images.

Integrations hub

Browse all integrations by category.