Drupal as AI Agent Marketplace

Last Updated: January 7, 2026 Drupal Version: 11.x Integration: GitLab Ultimate + Drupal AI Agents

Overview

Drupal 11 has evolved into a powerful platform for AI agent management, offering:

• 48+ AI Provider Integrations: OpenAI, Anthropic, Google, Azure, AWS, and more
• AI Agents Module: Full agent lifecycle management
• MCP Server/Client: Model Context Protocol integration
• Vector Databases: ChromaDB, Pinecone, Milvus, Weaviate support
• Agent Marketplace: Discover, install, and manage AI agents
• GitLab Integration: Direct integration with GitLab Duo platform

This makes Drupal an ideal agent marketplace for organizations to:

• Publish and discover agents
• Manage agent versions and dependencies
• Control access and permissions
• Monitor usage and costs
• Integrate with GitLab workflows

Drupal AI Architecture

Core Modules

1. AI Provider

• Package: drupal/ai
• Purpose: Unified interface for 48+ AI providers
• Repository: https://www.drupal.org/project/ai

// Unified AI provider interface
use Drupal\ai\AiProviderPluginManager;

$provider = \Drupal::service('ai.provider');

// Works with any provider (OpenAI, Anthropic, etc.)
$response = $provider->chat([
  'model' => 'claude-sonnet-4.5',
  'messages' => [
    ['role' => 'user', 'content' => 'Analyze this code...']
  ]
]);

2. AI Agents Module

• Package: drupal/ai_agents
• Purpose: Agent definition, execution, and management
• Repository: https://www.drupal.org/project/ai_agents

// Define an agent
$agent = AgentEntity::create([
  'name' => 'Code Reviewer',
  'type' => 'code_analysis',
  'model' => 'claude-sonnet-4.5',
  'system_prompt' => 'You are a code reviewer...',
  'tools' => ['gitlab_api', 'sast_scanner'],
]);
$agent->save();

// Execute agent
$result = $agent->execute([
  'merge_request_id' => 123,
  'project_id' => 456,
]);

3. AI MCP Module

• Package: drupal/ai_mcp
• Purpose: Model Context Protocol server and client
• Features:
  • MCP server: Expose Drupal APIs as tools
  • MCP client: Use external MCP servers
  • Tool discovery and registration

4. Vector Database Integration

• Package: drupal/ai_vector
• Supported Databases:
  • ChromaDB
  • Pinecone
  • Milvus
  • Weaviate
  • pgvector (PostgreSQL)

// Store embeddings
$vector_store = \Drupal::service('ai.vector.store');
$vector_store->addDocuments([
  ['content' => 'Documentation text...', 'metadata' => ['source' => 'docs']],
]);

// Similarity search
$results = $vector_store->similaritySearch('How to deploy agents?', $k = 5);

Agent Marketplace Setup

Installation

1. Install Drupal 11 with AI Modules

# Create new Drupal 11 project
composer create-project drupal/recommended-project:^11.0 agent-marketplace
cd agent-marketplace

# Install AI modules
composer require drupal/ai:^1.0
composer require drupal/ai_agents:^1.0
composer require drupal/ai_mcp:^1.0
composer require drupal/ai_vector:^1.0

# Install additional dependencies
composer require drupal/jsonapi:^11.0
composer require drupal/restui:^1.0
composer require drupal/oauth2_server:^2.0

# Enable modules
drush pm:enable ai ai_agents ai_mcp ai_vector jsonapi rest oauth2_server

2. Configure AI Providers

Navigate to: Administration † Configuration † AI † Providers

# config/sync/ai.provider.anthropic.yml
id: anthropic
label: 'Anthropic'
provider: anthropic
configuration:
  api_key: '<your-anthropic-api-key>'
  base_url: 'https://api.anthropic.com'
  models:
    - claude-sonnet-4.5
    - claude-opus-4.5
    - claude-haiku-4.0
  default_model: claude-sonnet-4.5

3. Setup Vector Database

# config/sync/ai.vector.chroma.yml
id: chroma
label: 'ChromaDB'
provider: chroma
configuration:
  host: 'localhost'
  port: 8000
  collection: 'agent_docs'
  embedding_model: 'text-embedding-3-small'

4. Configure MCP Server

# config/sync/ai_mcp.server.yml
mcp_server:
  enabled: true
  port: 3000
  base_path: '/mcp'

  tools:
    - id: drupal_get_agent
      name: drupal_get_agent
      description: 'Retrieve agent details from Drupal'

    - id: drupal_install_agent
      name: drupal_install_agent
      description: 'Install agent from marketplace'

    - id: drupal_search_agents
      name: drupal_search_agents
      description: 'Search available agents'

Content Types for Agent Marketplace

Agent Content Type (agent):

# config/sync/node.type.agent.yml
type: agent
name: 'AI Agent'
description: 'An AI agent that can be installed and executed'

# Fields:
fields:
  - field_agent_id:        # Unique identifier
      type: string
      required: true

  - field_agent_version:   # Semantic version
      type: string
      required: true

  - field_model:           # AI model (claude-sonnet-4.5, etc.)
      type: list_string

  - field_system_prompt:   # Agent's system prompt
      type: text_long

  - field_tools:           # Tools the agent uses
      type: entity_reference
      target_type: tool

  - field_ossa_spec:       # OSSA specification (YAML)
      type: text_long
      format: code

  - field_installation_count:  # Download/install counter
      type: integer

  - field_category:        # Agent category
      type: taxonomy_term
      vocabulary: agent_categories

  - field_gitlab_project:  # Associated GitLab project
      type: link

  - field_author:          # Agent author
      type: entity_reference
      target_type: user

Tool Content Type (tool):

# config/sync/node.type.tool.yml
type: tool
name: 'Agent Tool'
description: 'A tool that agents can use'

fields:
  - field_tool_name:       # Tool name
      type: string

  - field_tool_type:       # MCP, API, executable
      type: list_string

  - field_mcp_server:      # MCP server URL
      type: link

  - field_api_endpoint:    # API endpoint URL
      type: link

  - field_input_schema:    # JSON Schema for inputs
      type: text_long
      format: code

Agent Submission Workflow

1. Create Agent Submission Form

// modules/custom/agent_marketplace/src/Form/AgentSubmissionForm.php
namespace Drupal\agent_marketplace\Form;

use Drupal\Core\Form\FormBase;
use Drupal\Core\Form\FormStateInterface;

class AgentSubmissionForm extends FormBase {

  public function getFormId() {
    return 'agent_submission_form';
  }

  public function buildForm(array $form, FormStateInterface $form_state) {
    $form['agent_name'] = [
      '#type' => 'textfield',
      '#title' => $this->t('Agent Name'),
      '#required' => TRUE,
    ];

    $form['agent_description'] = [
      '#type' => 'textarea',
      '#title' => $this->t('Description'),
      '#required' => TRUE,
    ];

    $form['model'] = [
      '#type' => 'select',
      '#title' => $this->t('AI Model'),
      '#options' => [
        'claude-sonnet-4.5' => 'Claude Sonnet 4.5',
        'claude-opus-4.5' => 'Claude Opus 4.5',
        'gpt-4' => 'GPT-4',
      ],
      '#required' => TRUE,
    ];

    $form['system_prompt'] = [
      '#type' => 'textarea',
      '#title' => $this->t('System Prompt'),
      '#required' => TRUE,
    ];

    $form['ossa_spec'] = [
      '#type' => 'file',
      '#title' => $this->t('OSSA Specification (YAML)'),
      '#upload_validators' => [
        'file_validate_extensions' => ['yml yaml'],
      ],
    ];

    $form['gitlab_project'] = [
      '#type' => 'url',
      '#title' => $this->t('GitLab Project URL'),
      '#description' => $this->t('Link to the agent source code'),
    ];

    $form['submit'] = [
      '#type' => 'submit',
      '#value' => $this->t('Submit Agent for Review'),
    ];

    return $form;
  }

  public function submitForm(array &$form, FormStateInterface $form_state) {
    // Create agent node
    $agent = Node::create([
      'type' => 'agent',
      'title' => $form_state->getValue('agent_name'),
      'body' => ['value' => $form_state->getValue('agent_description')],
      'field_model' => $form_state->getValue('model'),
      'field_system_prompt' => $form_state->getValue('system_prompt'),
      'field_gitlab_project' => ['uri' => $form_state->getValue('gitlab_project')],
      'status' => 0, // Unpublished, pending review
      'uid' => \Drupal::currentUser()->id(),
    ]);
    $agent->save();

    // Trigger moderation workflow
    $this->triggerModeration($agent);

    $this->messenger()->addStatus($this->t('Agent submitted for review.'));
  }
}

2. Moderation Workflow

# config/sync/workflows.workflow.agent_moderation.yml
id: agent_moderation
label: 'Agent Moderation'
type: content_moderation
type_settings:
  states:
    draft:
      label: 'Draft'
      published: false

    pending_review:
      label: 'Pending Review'
      published: false

    security_review:
      label: 'Security Review'
      published: false

    approved:
      label: 'Approved'
      published: true

    rejected:
      label: 'Rejected'
      published: false

  transitions:
    submit:
      label: 'Submit for Review'
      from: [draft]
      to: pending_review

    approve_content:
      label: 'Approve Content'
      from: [pending_review]
      to: security_review

    approve_security:
      label: 'Approve Security'
      from: [security_review]
      to: approved

    reject:
      label: 'Reject'
      from: [pending_review, security_review]
      to: rejected

GitLab Integration

Drupal † GitLab Sync

Module: agent_marketplace_gitlab

// modules/custom/agent_marketplace_gitlab/src/GitLabSync.php
namespace Drupal\agent_marketplace_gitlab;

use Gitlab\Client as GitLabClient;

class GitLabSync {

  protected $gitlab;

  public function __construct() {
    $this->gitlab = GitLabClient::create('https://gitlab.com')
      ->authenticate(getenv('GITLAB_TOKEN'), GitLabClient::AUTH_HTTP_TOKEN);
  }

  /**
   * Sync Drupal agent to GitLab repository
   */
  public function syncAgentToGitLab($agent_node) {
    $project_id = $agent_node->field_gitlab_project_id->value;

    // Export agent to OSSA format
    $ossa_spec = $this->exportToOSSA($agent_node);

    // Create/update file in GitLab
    $this->gitlab->repositories->createFile(
      $project_id,
      [
        'file_path' => 'ossa-agent.yml',
        'branch' => 'main',
        'content' => $ossa_spec,
        'commit_message' => "Update agent from Drupal marketplace",
      ]
    );

    // Trigger CI/CD pipeline
    $this->gitlab->pipelines->create($project_id, 'main');
  }

  /**
   * Export Drupal agent to OSSA format
   */
  protected function exportToOSSA($agent_node) {
    $ossa = [
      'apiVersion' => 'ossa/v1',
      'kind' => 'Agent',
      'metadata' => [
        'name' => $agent_node->field_agent_id->value,
        'version' => $agent_node->field_agent_version->value,
        'description' => $agent_node->body->value,
      ],
      'spec' => [
        'model' => [
          'provider' => 'anthropic',
          'name' => $agent_node->field_model->value,
        ],
        'system_prompt' => $agent_node->field_system_prompt->value,
        'tools' => $this->getAgentTools($agent_node),
      ],
    ];

    return yaml_emit($ossa);
  }

  /**
   * Import agent from GitLab repository
   */
  public function importAgentFromGitLab($gitlab_url) {
    // Parse GitLab URL
    preg_match('#gitlab\.com/(.+)/(.+)#', $gitlab_url, $matches);
    $namespace = $matches[1];
    $project = $matches[2];
    $project_id = "$namespace/$project";

    // Fetch OSSA spec from repository
    $file = $this->gitlab->repositories->getFile(
      $project_id,
      'ossa-agent.yml',
      'main'
    );

    $ossa_spec = base64_decode($file['content']);
    $ossa = yaml_parse($ossa_spec);

    // Create Drupal agent node
    $agent = Node::create([
      'type' => 'agent',
      'title' => $ossa['metadata']['name'],
      'body' => ['value' => $ossa['metadata']['description']],
      'field_agent_id' => $ossa['metadata']['name'],
      'field_agent_version' => $ossa['metadata']['version'],
      'field_model' => $ossa['spec']['model']['name'],
      'field_system_prompt' => $ossa['spec']['system_prompt'],
      'field_ossa_spec' => $ossa_spec,
      'field_gitlab_project' => ['uri' => $gitlab_url],
    ]);
    $agent->save();

    return $agent;
  }
}

GitLab CI/CD Integration

Automated Agent Publishing:

# .gitlab-ci.yml (in agent repository)
stages:
  - validate
  - publish

validate_agent:
  stage: validate
  image: node:18
  script:
    # Validate OSSA specification
    - npm install -g @ossa/cli
    - ossa validate ossa-agent.yml

    # Run agent tests
    - npm ci
    - npm test

    # Security scan
    - glab duo agent run security_analyst --spec ossa-agent.yml

publish_to_drupal:
  stage: publish
  image: php:8.2-cli
  script:
    # Install Drupal CLI
    - curl -OL https://github.com/drush-ops/drush/releases/download/12.x/drush.phar
    - chmod +x drush.phar
    - mv drush.phar /usr/local/bin/drush

    # Publish agent to Drupal marketplace
    - |
      curl -X POST https://agents.yoursite.com/api/agents \
        -H "Authorization: Bearer $DRUPAL_API_TOKEN" \
        -H "Content-Type: application/json" \
        -d @ossa-agent.yml

    # Trigger Drupal cache clear
    - drush --uri=https://agents.yoursite.com cache-rebuild

  only:
    - tags  # Only publish on version tags

Webhook Integration

GitLab † Drupal Webhooks:

// modules/custom/agent_marketplace_gitlab/src/Controller/GitLabWebhook.php
namespace Drupal\agent_marketplace_gitlab\Controller;

use Drupal\Core\Controller\ControllerBase;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\JsonResponse;

class GitLabWebhook extends ControllerBase {

  /**
   * Handle GitLab webhook events
   */
  public function handleWebhook(Request $request) {
    $payload = json_decode($request->getContent(), TRUE);
    $event_type = $request->headers->get('X-Gitlab-Event');

    switch ($event_type) {
      case 'Push Hook':
        $this->handlePushEvent($payload);
        break;

      case 'Tag Push Hook':
        $this->handleTagEvent($payload);
        break;

      case 'Pipeline Hook':
        $this->handlePipelineEvent($payload);
        break;
    }

    return new JsonResponse(['status' => 'received']);
  }

  /**
   * Handle tag push (new version)
   */
  protected function handleTagEvent($payload) {
    $project_url = $payload['project']['web_url'];
    $tag = $payload['ref'];
    $version = str_replace('refs/tags/', '', $tag);

    // Find agent by GitLab URL
    $query = \Drupal::entityQuery('node')
      ->condition('type', 'agent')
      ->condition('field_gitlab_project.uri', $project_url);
    $nids = $query->execute();

    if (!empty($nids)) {
      $nid = reset($nids);
      $agent = Node::load($nid);

      // Update agent version
      $agent->field_agent_version = $version;
      $agent->save();

      // Re-import OSSA spec
      $sync = \Drupal::service('agent_marketplace_gitlab.sync');
      $sync->syncAgentFromGitLab($agent);

      \Drupal::logger('agent_marketplace')->notice(
        'Agent @name updated to version @version',
        ['@name' => $agent->getTitle(), '@version' => $version]
      );
    }
  }

  /**
   * Handle pipeline completion
   */
  protected function handlePipelineEvent($payload) {
    if ($payload['object_attributes']['status'] === 'success') {
      // Pipeline passed, agent is ready for publishing
      $project_id = $payload['project']['id'];

      // Auto-approve if tests passed
      $this->autoApproveAgent($project_id);
    }
  }
}

Agent Discovery & Installation

REST API

GET /api/agents - List Agents

curl https://agents.yoursite.com/api/agents \
  -H "Accept: application/json"

# Response:
{
  "data": [
    {
      "id": "code-reviewer",
      "type": "agent",
      "attributes": {
        "name": "Code Reviewer",
        "version": "0.4.9",
        "model": "claude-sonnet-4.5",
        "category": "code_analysis",
        "installation_count": 1523,
        "rating": 4.8
      },
      "links": {
        "self": "https://agents.yoursite.com/api/agents/code-reviewer",
        "gitlab": "https://gitlab.com/blueflyio/agents/code-reviewer"
      }
    }
  ]
}

POST /api/agents/install - Install Agent

curl -X POST https://agents.yoursite.com/api/agents/install \
  -H "Authorization: Bearer $DRUPAL_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "code-reviewer",
    "version": "0.4.9",
    "target": "gitlab"
  }'

# Response:
{
  "status": "installing",
  "agent_id": "code-reviewer",
  "version": "0.4.9",
  "installation_id": "inst-abc123"
}

CLI Tool

# Install Drupal agent marketplace CLI
npm install -g @drupal/agent-marketplace-cli

# Configure
drupal-agents config set --url https://agents.yoursite.com \
  --token $DRUPAL_API_TOKEN

# Search agents
drupal-agents search "code review"

# Show agent details
drupal-agents show code-reviewer

# Install agent
drupal-agents install code-reviewer --version 1.2.0

# List installed agents
drupal-agents list --installed

# Update agent
drupal-agents update code-reviewer --to 1.3.0

GraphQL API

# Query agents
query {
  agents(
    filter: {category: "code_analysis"}
    sort: {field: installation_count, direction: DESC}
    limit: 10
  ) {
    edges {
      node {
        id
        name
        version
        model
        category
        installationCount
        rating
        gitlabProject {
          url
        }
        author {
          name
          email
        }
      }
    }
  }
}

# Install agent mutation
mutation {
  installAgent(input: {
    agentId: "code-reviewer"
    version: "1.2.0"
    target: GITLAB
  }) {
    installationId
    status
    agent {
      id
      name
      version
    }
  }
}

Vector Search for Agent Discovery

Semantic Search:

// Search agents by natural language query
use Drupal\ai_vector\VectorStoreInterface;

$vector_store = \Drupal::service('ai.vector.store');

// Index all agents for vector search
$agents = Node::loadMultiple(
  \Drupal::entityQuery('node')
    ->condition('type', 'agent')
    ->execute()
);

foreach ($agents as $agent) {
  $vector_store->addDocument(
    id: $agent->id(),
    content: $agent->getTitle() . ' ' . $agent->body->value,
    metadata: [
      'category' => $agent->field_category->entity->getName(),
      'model' => $agent->field_model->value,
      'rating' => $agent->field_rating->value,
    ]
  );
}

// Semantic search
$results = $vector_store->similaritySearch(
  query: 'I need an agent to review my Python code for security issues',
  k: 5
);

foreach ($results as $result) {
  $agent = Node::load($result['id']);
  echo $agent->getTitle() . ' (score: ' . $result['score'] . ')' . PHP_EOL;
}

Drupal View with Vector Search:

# config/sync/views.view.agent_search.yml
id: agent_search
label: 'Agent Search'
display:
  default:
    display_options:
      exposed_form:
        type: basic
        options:
          submit_button: 'Search Agents'
          exposed_sorts_label: 'Sort by'
      filters:
        search_query:
          id: search_query
          expose:
            label: 'Search'
            operator: search_query_op
          plugin_id: ai_vector_search  # Custom plugin

Agent Rating & Reviews

Rating System:

# config/sync/field.storage.node.field_rating.yml
field_name: field_rating
entity_type: node
type: fivestar
settings:
  display_format: average
  stars: 5
  allow_revote: true

Review Content Type:

// Allow users to review agents
$review = Node::create([
  'type' => 'agent_review',
  'title' => "Review of {$agent->getTitle()}",
  'field_agent_reference' => ['target_id' => $agent->id()],
  'field_rating' => 5,
  'body' => 'This agent works great for code reviews!',
  'uid' => \Drupal::currentUser()->id(),
]);
$review->save();

Agent Analytics

Usage Tracking:

// Track agent installations and usage
use Drupal\Core\Entity\EntityInterface;

/**
 * Implements hook_ENTITY_TYPE_insert() for agent_installation
 */
function agent_marketplace_node_insert(EntityInterface $entity) {
  if ($entity->bundle() === 'agent_installation') {
    $agent_id = $entity->field_agent->target_id;
    $agent = Node::load($agent_id);

    // Increment installation count
    $count = $agent->field_installation_count->value ?? 0;
    $agent->field_installation_count = $count + 1;
    $agent->save();

    // Log to analytics
    \Drupal::service('agent_marketplace.analytics')->trackInstallation([
      'agent_id' => $agent_id,
      'user_id' => $entity->getOwnerId(),
      'timestamp' => time(),
    ]);
  }
}

Analytics Dashboard (Views + Charts):

# config/sync/views.view.agent_analytics.yml
id: agent_analytics
label: 'Agent Analytics'
display:
  default:
    display_options:
      fields:
        title:
          id: title
          label: 'Agent Name'
        field_installation_count:
          id: field_installation_count
          label: 'Installations'
        field_rating:
          id: field_rating
          label: 'Rating'
      sorts:
        field_installation_count:
          id: field_installation_count
          order: DESC

Security & Compliance

Agent Security Scanning

Automated Security Review:

// modules/custom/agent_marketplace_security/src/SecurityScanner.php
namespace Drupal\agent_marketplace_security;

class SecurityScanner {

  /**
   * Scan agent for security issues
   */
  public function scanAgent($agent_node) {
    $issues = [];

    // Check system prompt for injection vulnerabilities
    $prompt = $agent_node->field_system_prompt->value;
    if ($this->detectPromptInjection($prompt)) {
      $issues[] = [
        'severity' => 'high',
        'type' => 'prompt_injection',
        'message' => 'Potential prompt injection detected',
      ];
    }

    // Validate OSSA specification
    $ossa_spec = $agent_node->field_ossa_spec->value;
    $ossa_issues = $this->validateOSSA($ossa_spec);
    $issues = array_merge($issues, $ossa_issues);

    // Check for unsafe tool usage
    foreach ($agent_node->field_tools as $tool) {
      if ($this->isUnsafeTool($tool->entity)) {
        $issues[] = [
          'severity' => 'critical',
          'type' => 'unsafe_tool',
          'message' => "Tool {$tool->entity->label()} requires review",
        ];
      }
    }

    return $issues;
  }

  /**
   * Run GitLab Security Analyst on agent code
   */
  public function runGitLabSecurityScan($gitlab_project_url) {
    // Trigger GitLab Duo Security Analyst
    $result = shell_exec("
      glab duo agent run security_analyst \
        --project '{$gitlab_project_url}' \
        --output json
    ");

    return json_decode($result, TRUE);
  }
}

Access Control

Role-Based Permissions:

# config/sync/user.role.agent_publisher.yml
id: agent_publisher
label: 'Agent Publisher'
permissions:
  - 'create agent content'
  - 'edit own agent content'
  - 'delete own agent content'
  - 'access agent submission form'

# config/sync/user.role.agent_moderator.yml
id: agent_moderator
label: 'Agent Moderator'
permissions:
  - 'moderate agent content'
  - 'approve agents'
  - 'reject agents'
  - 'access security scanner'

Cost Management

Token Usage Tracking:

// Track AI token usage per agent
use Drupal\ai\Event\AiResponseEvent;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

class TokenUsageTracker implements EventSubscriberInterface {

  public static function getSubscribedEvents() {
    return [
      AiResponseEvent::class => 'onAiResponse',
    ];
  }

  public function onAiResponse(AiResponseEvent $event) {
    $response = $event->getResponse();
    $tokens_used = $response->getUsage()['total_tokens'];

    // Log token usage
    \Drupal::database()->insert('agent_token_usage')
      ->fields([
        'agent_id' => $event->getAgentId(),
        'tokens_input' => $response->getUsage()['prompt_tokens'],
        'tokens_output' => $response->getUsage()['completion_tokens'],
        'cost' => $this->calculateCost($tokens_used, $event->getModel()),
        'timestamp' => time(),
      ])
      ->execute();
  }

  protected function calculateCost($tokens, $model) {
    $rates = [
      'claude-sonnet-4.5' => [
        'input' => 0.003,   // $3 per million
        'output' => 0.015,  // $15 per million
      ],
    ];

    $rate = $rates[$model] ?? ['input' => 0, 'output' => 0];
    return ($tokens * ($rate['input'] + $rate['output'])) / 1000000;
  }
}

Cost Allocation:

// Generate cost report per agent
$query = \Drupal::database()->select('agent_token_usage', 'atu')
  ->fields('atu', ['agent_id'])
  ->addExpression('SUM(tokens_input + tokens_output)', 'total_tokens')
  ->addExpression('SUM(cost)', 'total_cost')
  ->groupBy('agent_id')
  ->orderBy('total_cost', 'DESC');

$results = $query->execute()->fetchAll();

foreach ($results as $row) {
  $agent = Node::load($row->agent_id);
  echo "{$agent->getTitle()}: \${$row->total_cost} ({$row->total_tokens} tokens)\n";
}

Complete Integration Example

Scenario: Publish Code Review Agent to Drupal Marketplace

Step 1: Create Agent in GitLab

# Create agent repository
glab repo create blueflyio/code-review-agent

cd code-review-agent

# Create OSSA specification
cat > ossa-agent.yml <<EOF
apiVersion: ossa/v1
kind: Agent
metadata:
  name: code-review-agent
  version: 1.0.0
  description: AI-powered code review for merge requests

spec:
  model:
    provider: anthropic
    name: claude-sonnet-4.5

  system_prompt: |
    You are an expert code reviewer...

  tools:
    - name: gitlab_get_mr
      type: gitlab_api
    - name: sast_scan
      type: security
EOF

# Add CI/CD pipeline
cat > .gitlab-ci.yml <<EOF
include:
  - project: blueflyio/agent-platform/gitlab-components
    file: /agent-publish.yml

publish:
  extends: .agent_publish
  variables:
    DRUPAL_MARKETPLACE: https://agents.yoursite.com
EOF

# Commit and push
git add .
git commit -m "feat: initial agent implementation"
git push origin main

Step 2: Agent CI/CD Pipeline Runs

• Validates OSSA specification
• Runs tests
• Security scan (GitLab Duo Security Analyst)
• Publishes to Drupal marketplace via API

Step 3: Drupal Receives Agent

// Webhook handler creates agent node
$agent = Node::create([
  'type' => 'agent',
  'title' => 'Code Review Agent',
  'field_agent_id' => 'code-review-agent',
  'field_agent_version' => '1.0.0',
  'field_model' => 'claude-sonnet-4.5',
  'field_gitlab_project' => ['uri' => 'https://gitlab.com/blueflyio/code-review-agent'],
  'status' => 0, // Pending review
]);
$agent->save();

Step 4: Agent Moderation

• Content review (description, prompt quality)
• Security review (automated + manual)
• Approval † Agent published

Step 5: Users Discover & Install

# User searches marketplace
drupal-agents search "code review"

# Installs agent
drupal-agents install code-review-agent

# Agent installed to GitLab project
glab duo agent list
# code-review-agent v1.0.0 (installed)

Step 6: Analytics & Feedback

• Installation count incremented
• Usage tracked (token usage, cost)
• Users leave ratings and reviews

Resources

Drupal AI Modules

• AI Module: https://www.drupal.org/project/ai
• AI Agents: https://www.drupal.org/project/ai_agents
• AI MCP: https://www.drupal.org/project/ai_mcp
• AI Vector: https://www.drupal.org/project/ai_vector

Documentation

• Drupal AI Documentation: https://drupal-ai.gitbook.io
• MCP Integration Guide: https://drupal-ai.gitbook.io/mcp
• Agent Development Guide: https://drupal-ai.gitbook.io/agents

Community

• Drupal AI Slack: https://drupal.slack.com #ai
• Issue Queue: https://www.drupal.org/project/issues/ai
• GitLab Integration Examples: https://gitlab.com/drupal-ai-examples

Next Steps

1. Setup Drupal 11 Instance: Install with AI modules
2. Configure AI Providers: Add Anthropic/OpenAI API keys
3. Enable MCP Server: Expose Drupal as tool provider
4. Create Agent Content Types: Setup marketplace structure
5. Integrate with GitLab: Configure webhooks and CI/CD
6. Publish First Agent: Test complete workflow

---

Related Documentation:

• Foundational Agents & Flows
• Agent Interoperability Standards
• Platform Agents Repository