MCP Server GitLab

https://github.com/zephyrdeng/mcp-server-gitlab
Admin
A GitLab integration server built on the fastmcp framework, providing various GitLab RESTful API...
Tokens:45,393
Snippets:454
Trust Score:5.9
License:MIT
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install, Build, and Start Server (Stdio Mode)

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/README.md

Install dependencies, build the project, and start the server using the default stdio transport. This is the default mode for the server.

```bash
bun install

bun run build

bun run start
```

--------------------------------

### Complete FastMCP Project Example with GitLab Tools

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/README_TOOLS.md

This snippet shows a full FastMCP server setup, registering GitLab tools with specific configurations for logging and tool filtering. It demonstrates how to start the server using stdio transport.

```typescript
#!/usr/bin/env node

import { FastMCP } from 'fastmcp';
import { registerGitLabToolsForFastMCP } from '@zephyr-mcp/gitlab/tools';

const server = new FastMCP({
  name: 'my-gitlab-app',
  version: '1.0.0'
});

// 注册 GitLab 工具
registerGitLabToolsForFastMCP(server, {
  enableLogger: true,
  toolFilter: {
    allowList: ["Gitlab_Create_MR_Tool", "Gitlab_Search_User_Projects_Tool"]
  }
});

// 启动服务器
server.start({
  transportType: 'stdio'
});

```

--------------------------------

### Install, Build, and Start Server (HTTP Stream Mode)

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/README.md

Install dependencies, build the project, and start the server using the HTTP stream transport. This mode is suitable for server deployments and can be configured with a specific port.

```bash
# Install dependencies
bun install

# Build the project
bun run build

# Start the server with HTTP stream transport
MCP_TRANSPORT_TYPE=httpStream MCP_PORT=3000 bun run start

# Or using command line flag
bun dist/index.js --http-stream
```

--------------------------------

### Server Startup Example

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/overview.md

Demonstrates how to start the mcp-server-gitlab directly using npx.

```typescript
// Server startup - run directly
npx @zephyr-mcp/gitlab
```

--------------------------------

### Manual Deployment: Install, Build, and Start Server

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/README.md

Steps for manually deploying the GitLab MCP server. Includes installing dependencies, building the project, and starting the server in HTTP stream mode with necessary environment variables.

```bash
# Install dependencies and build
npm install
npm run build

# Start the server in HTTP stream mode
export GITLAB_API_URL=https://your-gitlab-instance.com
export GITLAB_TOKEN=your_access_token
export MCP_TRANSPORT_TYPE=httpStream
export MCP_PORT=3000

# Run the server
node dist/index.js
```

--------------------------------

### FastMCP Server Setup with GitLab Tools

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/server-integration.md

Sets up a FastMCP server instance, registers GitLab tools with optional filtering and logging, and starts the server using stdio transport.

```typescript
import { FastMCP } from 'fastmcp';
import { registerGitLabToolsForFastMCP } from '@zephyr-mcp/gitlab/tools';
import type { GitLabSessionWithExtras } from '@zephyr-mcp/gitlab';

// Create FastMCP server instance
const server = new FastMCP<GitLabSessionWithExtras>({
  name: 'my-gitlab-server',
  version: '1.0.0',
  authenticate: async (request) => {
    // Extract GitLab credentials from headers
    const token = request?.headers?.['authorization']?.replace('Bearer ', '');
    const baseUrl = request?.headers?.['x-gitlab-url'];
    
    return {
      gitlabToken: token,
      gitlabBaseUrl: baseUrl,
      headers: request?.headers || {},
      authenticatedAt: new Date().toISOString()
    };
  }
});

// Register GitLab tools
registerGitLabToolsForFastMCP(server, {
  toolFilter: {
    allowList: ['Gitlab_Create_MR_Tool', 'Gitlab_Update_MR_Tool']
  },
  enableLogger: process.env.DEBUG === 'true'
});

// Start server
server.start({
  transportType: 'stdio'
  // or
  // transportType: 'httpStream',
  // httpStream: { host: '0.0.0.0', port: 3000, endpoint: '/mcp' }
});
```

--------------------------------

### Systemd Service Setup and Management

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/server-integration.md

Commands to set up a Systemd service for the gitlab-mcp application, including user creation, directory setup, permissions, and service management.

```bash
# Create user
useradd -m -s /bin/false gitlab-mcp

# Create directories
mkdir -p /opt/gitlab-mcp
mkdir -p /etc/gitlab-mcp
mkdir -p /var/log/gitlab-mcp

# Set permissions
chown gitlab-mcp:gitlab-mcp /opt/gitlab-mcp
chown gitlab-mcp:gitlab-mcp /var/log/gitlab-mcp

# Create env file with sensitive data
echo "GITLAB_TOKEN=glpat-xxx" > /etc/gitlab-mcp/env
chmod 600 /etc/gitlab-mcp/env
chown gitlab-mcp:gitlab-mcp /etc/gitlab-mcp/env

# Enable and start service
systemctl daemon-reload
systemctl enable gitlab-mcp
systemctl start gitlab-mcp

# Monitor
journalctl -u gitlab-mcp -f
systemctl status gitlab-mcp

```

--------------------------------

### Tools SDK Import Example

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/overview.md

Shows how to import the tools SDK for integration with other projects.

```typescript
// Tools SDK - import for integration
import { registerGitLabToolsForFastMCP } from '@zephyr-mcp/gitlab/tools'
```

--------------------------------

### PM2 Process Manager Configuration and Start

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/README.md

Instructions for using PM2 to manage the GitLab MCP server process. Includes installing PM2, creating an ecosystem file, and starting/saving the process.

```bash
# Install PM2
npm install -g pm2

# Create ecosystem file
cat > ecosystem.config.js << EOF
module.exports = {
  apps: [{
    name: 'gitlab-mcp-server',
    script: 'dist/index.js',
    env: {
      GITLAB_API_URL: 'https://your-gitlab-instance.com',
      GITLAB_TOKEN: 'your_access_token',
      MCP_TRANSPORT_TYPE: 'httpStream',
      MCP_PORT: 3000
    }
  }]
}
EOF

# Start with PM2
pm2 start ecosystem.config.js
pm2 save
pm2 startup
```

--------------------------------

### Start Server in HTTP Stream Mode

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Environment variables and command to start the MCP server in HTTP stream mode.

```bash
export MCP_TRANSPORT_TYPE=httpStream
export MCP_HOST=0.0.0.0
export MCP_PORT=3000
export MCP_ENDPOINT=/mcp

npx @zephyr-mcp/gitlab
```

--------------------------------

### LoggerLike Implementation Example

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/types.md

Provides an example implementation of the LoggerLike interface using console methods. Shows how to set a custom logger for the GitlabApiClient.

```typescript
class MyLogger implements LoggerLike {
  info(...args: any[]) {
    console.log('[INFO]', ...args);
  }
  warn(...args: any[]) {
    console.warn('[WARN]', ...args);
  }
  error(...args: any[]) {
    console.error('[ERROR]', ...args);
  }
  debug(...args: any[]) {
    console.debug('[DEBUG]', ...args);
  }
}

const client = new GitlabApiClient(config);
client.setLogger(new MyLogger());
```

--------------------------------

### Start HTTP Stream Server with Environment Variables

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/README.md

Command to start the MCP server in HTTP Stream mode, listening on port 3000 on all interfaces. Environment variables for token and URL are optional when using headers.

```bash
# On your server - no token or URL required in env vars
MCP_TRANSPORT_TYPE=httpStream MCP_PORT=3000 MCP_HOST=0.0.0.0 npx @zephyr-mcp/gitlab
```

--------------------------------

### Direct HTTP API Usage: Search Projects

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/README.md

Example of how to call the 'Gitlab Search Project Details Tool' via a direct HTTP POST request. This example uses the PRIVATE-TOKEN header for authentication.

```bash
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -H "PRIVATE-TOKEN: your-gitlab-token" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "Gitlab Search Project Details Tool",
      "arguments": {
        "projectName": "my-project",
        "fields": ["id", "name", "description", "web_url"]
      }
    }
  }'
```

--------------------------------

### Example: Use dynamic GitLab instance URL with Bearer token

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/README.md

This example demonstrates how to make a POST request to the MCP server, specifying a dynamic GitLab instance URL and using a Bearer token for authorization. It includes the method and parameters for fetching user tasks.

```bash
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-gitlab-token" \
  -H "x-gitlab-url: https://gitlab.company.com" \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
      "name": "Gitlab Get User Tasks Tool",
      "arguments": {
        "taskFilterType": "ASSIGNED_MRS",
        "fields": ["id", "title", "source_branch", "target_branch"]
      }
    }
  }'
```

--------------------------------

### Starting Multiple MCP Server Instances

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/server-integration.md

Launch multiple instances of the MCP server on different ports using environment variables to specify the port. This is typically followed by starting HAProxy.

```bash
# Start multiple instances on different ports
MCP_PORT=3001 npm start &
MCP_PORT=3002 npm start &
MCP_PORT=3003 npm start &

# Point HAProxy at 3000
haproxy -f /etc/haproxy/haproxy.cfg
```

--------------------------------

### Load Environment Variables with dotenv

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/configuration.md

This example demonstrates how to load environment variables from a .env file using `dotenv` before running a Node.js application. Ensure the .env file is correctly formatted and the `dotenv` package is installed.

```bash
# .env file
GITLAB_API_URL=https://gitlab.com
GITLAB_TOKEN=glpat-xxx
GITLAB_USER_MAPPING={"john": 123}

# Load before running
node -r dotenv/config dist/index.js
```

--------------------------------

### GitlabConfigOptions Example

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/types.md

Demonstrates how to instantiate GitlabConfigOptions with specific values for base URL, private token, timeout, and mappings.

```typescript
import { GitlabConfigOptions } from '@zephyr-mcp/gitlab';

const options: GitlabConfigOptions = {
  baseUrl: 'https://gitlab.company.com',
  privateToken: 'glpat-xxx',
  timeout: 20000,
  userMapping: { 'john': 123 },
  projectMapping: { 'backend': 456 }
};
```

--------------------------------

### List Tools using curl

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Example of listing tools using curl with POST request.

```bash
# List tools
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer glpat-xxx" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
```

--------------------------------

### Direct HTTP API Usage: Get User Tasks

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/README.md

Example of how to call the 'Gitlab Get User Tasks Tool' via a direct HTTP POST request. Requires Content-Type and Authorization headers, and a JSON-RPC payload.

```bash
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-gitlab-token" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "Gitlab Get User Tasks Tool",
      "arguments": {
        "taskFilterType": "ASSIGNED_MRS",
        "fields": ["id", "title", "source_branch", "target_branch"]
      }
    }
  }'
```

--------------------------------

### List Tools using Python

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Example of listing tools using Python's requests library.

```python
import requests
import json

url = "http://localhost:3000/mcp"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer glpat-xxx",
    "x-gitlab-url": "https://gitlab.company.com"
}

payload = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {}
}

response = requests.post(url, headers=headers, json=payload)
print(response.json())
```

--------------------------------

### HTTP Header Authentication for Stream Mode Server Start

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/server-integration.md

Starts the MCP server in httpStream mode, listening on a specified host and port, without initial credentials.

```bash
# Start server without credentials
export MCP_TRANSPORT_TYPE=httpStream
export MCP_HOST=0.0.0.0
export MCP_PORT=3000

npx @zephyr-mcp/gitlab
```

--------------------------------

### MCP SDK Server Setup with GitLab Tools

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/server-integration.md

Initializes an MCP SDK server and registers GitLab tools, connecting the server using a StdioClientTransport.

```typescript
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { registerGitLabToolsForMcpSDK } from '@zephyr-mcp/gitlab/tools';

const server = new McpServer({
  name: 'my-gitlab-server',
  version: '1.0.0',
  capabilities: {
    tools: {}
  }
});

// Register GitLab tools
registerGitLabToolsForMcpSDK(server, {
  enableLogger: true
});

// Start server
server.connect(
  new StdioClientTransport()
);
```

--------------------------------

### List Tools using JavaScript Fetch API

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Example of listing tools using the Fetch API.

```javascript
const response = await fetch('http://localhost:3000/mcp', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer glpat-xxx',
    'x-gitlab-url': 'https://gitlab.company.com'
  },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'tools/list',
    params: {}
  })
});

const data = await response.json();
console.log(data);
```

--------------------------------

### Instantiate GitlabConfig with baseUrl

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/configuration.md

Examples of initializing GitlabConfig with different baseUrl formats. The baseUrl is automatically normalized to include '/api/v4'.

```typescript
new GitlabConfig({ baseUrl: 'https://gitlab.com/api/v4' })

// Will be normalized
new GitlabConfig({ baseUrl: 'https://gitlab.com' })
new GitlabConfig({ baseUrl: 'gitlab.com' })

// Self-hosted
new GitlabConfig({ baseUrl: 'https://gitlab.company.com' })
```

--------------------------------

### List Tools using Node.js http module

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Example of listing tools using Node.js built-in http module.

```javascript
const http = require('http');

const options = {
  hostname: 'localhost',
  port: 3000,
  path: '/mcp',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer glpat-xxx',
    'x-gitlab-url': 'https://gitlab.company.com'
  }
};

const req = http.request(options, (res) => {
  let data = '';
  res.on('data', chunk => data += chunk);
  res.on('end', () => console.log(JSON.parse(data)));
});

req.write(JSON.stringify({
  jsonrpc: '2.0',
  id: 1,
  method: 'tools/list',
  params: {}
}));
req.end();
```

--------------------------------

### Gitlab Get User Tasks Tool Example

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/tools-overview.md

Use this tool to retrieve the current user's tasks or merge requests with optional filtering by type and specific fields.

```javascript
{
  "taskFilterType": "ASSIGNED_MRS",
  "fields": ["id", "title", "source_branch", "target_branch"]
}
```

--------------------------------

### Instantiate GitlabConfig with userMapping

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/configuration.md

Example of configuring GitlabConfig with a user mapping to cache username-to-user-ID lookups, improving performance.

```typescript
new GitlabConfig({
  userMapping: {
    'john.doe': 123,
    'jane.smith': 456,
    'admin': 1
  }
})
```

--------------------------------

### GitlabApiResponse Success Example

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/types.md

An example of a successful response object from the GitLab API, typically containing project details.

```json
{
  "id": 123,
  "name": "my-project",
  "description": "Project description",
  "web_url": "https://gitlab.com/my-project"
}
```

--------------------------------

### Create GitLabSession Instance

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/types.md

Example of creating a GitLabSession object with essential authentication details. Ensure gitlabToken and gitlabBaseUrl are provided for proper integration.

```typescript
import { GitLabSession } from '@zephyr-mcp/gitlab';

const session: GitLabSession = {
  gitlabToken: 'glpat-xxx',
  gitlabBaseUrl: 'https://gitlab.com/api/v4',
  authenticatedAt: new Date().toISOString(),
  userId: '123',
  username: 'john.doe'
};
```

--------------------------------

### Run MCP Server in Stdio Mode

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/configuration.md

Example of setting environment variables for GitLab authentication and mapping, then running the MCP server in default stdio mode.

```bash
export GITLAB_API_URL=https://gitlab.com
export GITLAB_TOKEN=glpat-xxxxxxxxxxxxxxxxxx
export GITLAB_USER_MAPPING='{"john": 123}'
export GITLAB_PROJECT_MAPPING='{"myapp": 456}'

npx @zephyr-mcp/gitlab
```

--------------------------------

### MCP Protocol tools/list Response

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Example JSON-RPC 2.0 response detailing available tools and their schemas.

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tools": [
      {
        "name": "Gitlab Search User Projects Tool",
        "description": "Search users and projects by username",
        "inputSchema": {
          "type": "object",
          "properties": {
            "username": { "type": "string" },
            "fields": { "type": "array", "items": { "type": "string" } }
          },
          "required": ["username"]
        }
      },
      // ... other tools
    ]
  }
}
```

--------------------------------

### Programmatic MCP GitLab Client Initialization

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/configuration.md

Example of initializing the GitlabConfig and GitlabApiClient programmatically in TypeScript, setting various configuration options.

```typescript
import { GitlabConfig } from '@zephyr-mcp/gitlab';
import { GitlabApiClient } from '@zephyr-mcp/gitlab/tools';

const config = new GitlabConfig({
  baseUrl: 'https://gitlab.company.com',
  privateToken: 'glpat-...',
  timeout: 20000,
  userMapping: { 'john': 123 },
  projectMapping: { 'backend': 456 }
});

const client = new GitlabApiClient(config);
const user = await client.apiRequest('/user', 'GET');
```

--------------------------------

### Perform GET Request with Parameters

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/api-client.md

Make a GET request to a GitLab API endpoint, including query parameters for filtering or pagination. The endpoint and parameters are specified as arguments.

```typescript
// GET request with parameters
const projects = await client.apiRequest('/projects', 'GET', {
  search: 'my-project',
  per_page: 10
});
```

--------------------------------

### Run MCP Server in HTTP Stream Mode

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/configuration.md

Example of configuring MCP server for HTTP stream mode and running it. GitLab API URL and token are optional here as they can be provided per-request.

```bash
export MCP_TRANSPORT_TYPE=httpStream
export MCP_PORT=3000
export MCP_HOST=0.0.0.0
# GITLAB_API_URL and GITLAB_TOKEN are optional

npx @zephyr-mcp/gitlab
```

--------------------------------

### Gitlab_Search_User_Projects_Tool Parameters

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/tools-overview.md

Example parameters for the Gitlab_Search_User_Projects_Tool. Supports field filtering using arrays or comma-separated strings for nested paths.

```javascript
// Using fields as array
{
  "username": "john.doe",
  "fields": ["user.id", "user.username", "projects[0].name"]
}

// Using fields as comma-separated string
{
  "username": "john.doe",
  "fields": "user.id,user.username,projects.length"
}
```

--------------------------------

### Instantiate GitlabConfig with privateToken

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/configuration.md

Example of initializing GitlabConfig with a private token for API authentication. The token is used in the 'PRIVATE-TOKEN' header.

```typescript
new GitlabConfig({ privateToken: 'glpat-xxxxxxxxxxxxxxxxxx' })
```

--------------------------------

### Instantiate GitlabConfig with projectMapping

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/configuration.md

Example of configuring GitlabConfig with a project mapping to cache project-name-to-project-ID lookups. Supports numeric IDs or path formats.

```typescript
new GitlabConfig({
  projectMapping: {
    'my-project': 123,
    'another-project': 456,
    'group/project': 'group/project',
    'company/backend': 'company/engineering/backend'
  }
})
```

--------------------------------

### Configure GitLab Tool Registration with Options

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/types.md

Example of configuring GitLab tool registration with specific options, such as blocking the raw API tool and enabling debug logging. This demonstrates how to customize the tool registration process.

```typescript
const options: GitLabToolsRegistryOptions = {
  toolFilter: {
    blockList: ['Gitlab_Raw_API_Tool'] // Disable raw API access
  },
  enableLogger: true
};

registerGitLabToolsForFastMCP(server, options);
```

--------------------------------

### Gitlab Search Project Details Tool Example

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/tools-overview.md

Searches for Gitlab projects by name and retrieves detailed information, filtering the response to specified fields.

```javascript
{
  "projectName": "my-project",
  "fields": ["id", "name", "description", "web_url"]
}
```

--------------------------------

### PM2 Management Commands

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/server-integration.md

Common commands for managing Node.js applications with PM2, including starting, monitoring, and logging.

```bash
# Start
pm2 start ecosystem.config.js

# Monitor
pm2 monit

# Logs
pm2 logs gitlab-mcp

# Stop
pm2 stop gitlab-mcp

# Restart
pm2 restart gitlab-mcp

# Save configuration
pm2 save

# Auto start on reboot
pm2 startup

```

--------------------------------

### Dockerfile for MCP GitLab Server

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/server-integration.md

A Dockerfile to build an image for the mcp-server-gitlab, installing the package globally and setting up an entrypoint script.

```dockerfile
FROM node:22.14.0-alpine

WORKDIR /app

# Install package
RUN npm install -g @zephyr-mcp/gitlab

# Create entrypoint script
RUN echo '#!/bin/sh\nexec @zephyr-mcp/gitlab' > /entrypoint.sh && \
    chmod +x /entrypoint.sh

ENTRYPOINT ["/entrypoint.sh"]
```

--------------------------------

### Custom Logger Implementation and Client Setup

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/api-client.md

Implements the LoggerLike interface to create a custom logger and sets it on the GitlabApiClient instance. This allows for customized logging behavior.

```typescript
class CustomLogger implements LoggerLike {
  info(...args: any[]) {
    console.log('[INFO]', ...args);
  }
  warn(...args: any[]) {
    console.warn('[WARN]', ...args);
  }
  error(...args: any[]) {
    console.error('[ERROR]', ...args);
  }
  debug(...args: any[]) {
    console.debug('[DEBUG]', ...args);
  }
}

const client = new GitlabApiClient(config);
client.setLogger(new CustomLogger());
```

--------------------------------

### extractGitlabToken Example

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/types.md

Shows how to safely extract a GitLab token from a session object using the extractGitlabToken utility function. Handles cases where the token might be undefined.

```typescript
const token = extractGitlabToken(context.session);
if (token) {
  console.log('Authenticated with token:', token.substring(0, 10) + '...');
}
```

--------------------------------

### Set GITLAB_API_URL Environment Variable

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/configuration.md

Examples of setting the GITLAB_API_URL environment variable to specify the base URL for the GitLab API instance.

```bash
export GITLAB_API_URL=https://gitlab.com
export GITLAB_API_URL=https://gitlab.company.com
```

--------------------------------

### Filter GitLab Tools with Allow List

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/types.md

Example of using GitLabToolFilterOptions to specify an allow list of tools to be registered. Only tools in this list will be registered.

```typescript
import { GitLabToolName } from '@zephyr-mcp/gitlab/tools';

const allowedTools: GitLabToolName[] = [
  'Gitlab_Search_User_Projects_Tool',
  'Gitlab_Create_MR_Tool'
];
```

--------------------------------

### Environment Variable Authentication for Stdio Mode

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/server-integration.md

Configures GitLab API URL, token, and ID mappings via environment variables for a single-user server setup in stdio mode.

```bash
#!/bin/bash
export GITLAB_API_URL=https://gitlab.company.com
export GITLAB_TOKEN=glpat-xxxxxxxxxxxxxxxxxx
export GITLAB_USER_MAPPING='{"john": 123}'
export GITLAB_PROJECT_MAPPING='{"backend": 456}'

npx @zephyr-mcp/gitlab
```

--------------------------------

### Call Gitlab Search Project Details Tool

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Example curl request to call the 'Gitlab Search Project Details Tool' with project name and desired fields.

```bash
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer glpat-xxx" \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
      "name": "Gitlab Search Project Details Tool",
      "arguments": {
        "projectName": "my-project",
        "fields": ["id", "name", "description", "web_url"]
      }
    }
  }'
```

--------------------------------

### Call Gitlab Search User Projects Tool

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Example curl request to call the 'Gitlab Search User Projects Tool' with specific arguments and headers.

```bash
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer glpat-xxx" \
  -H "x-gitlab-url: https://gitlab.company.com" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "Gitlab Search User Projects Tool",
      "arguments": {
        "username": "john.doe",
        "fields": ["id", "username", "projects"]
      }
    }
  }'
```

--------------------------------

### Call Gitlab Get User Tasks Tool

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Example curl request to call the 'Gitlab Get User Tasks Tool' using a PRIVATE-TOKEN for authentication.

```bash
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -H "PRIVATE-TOKEN: glpat-xxx" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "Gitlab Get User Tasks Tool",
      "arguments": {
        "taskFilterType": "ASSIGNED_MRS",
        "fields": ["id", "title", "source_branch"]
      }
    }
  }'
```

--------------------------------

### Default GitLab API Client Instance

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/utilities.md

Provides a pre-configured default GitLab API client instance that uses environment variables for initialization. This instance can be configured further, for example, by setting a logger.

```typescript
export const gitlabApiClient: GitlabApiClient
```

```typescript
import { gitlabApiClient } from '@zephyr-mcp/gitlab/tools';

// Enable logging
gitlabApiClient.setLogger(console);

// Use directly
const projects = await gitlabApiClient.apiRequest('/projects', 'GET');
```

--------------------------------

### Inspect API Requests using Raw API Tool

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/errors.md

Example configuration for the Raw API Tool, used to directly call GitLab API endpoints and inspect the request/response details.

```json
{
  "endpoint": "/projects/123",
  "method": "GET"
}
```

--------------------------------

### Run GitLab MCP Server with Docker

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/README.md

Starts the GitLab MCP server in detached mode using Docker. It maps port 3000 and sets environment variables for transport type, host, and port.

```bash
docker run -d \
  -p 3000:3000 \
  -e MCP_TRANSPORT_TYPE=httpStream \
  -e MCP_HOST=0.0.0.0 \
  -e MCP_PORT=3000 \
  gitlab-mcp-server
```

--------------------------------

### Register GitLab Tools with Filter Options

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/types.md

Example of registering GitLab tools using GitLabToolsRegistryOptions, including a block list to disable specific tools and enable logging. This configuration allows fine-grained control over tool availability and debugging.

```typescript
const filter: GitLabToolFilterOptions = {
  allowList: ['Gitlab_Create_MR_Tool', 'Gitlab_Update_MR_Tool']
};

registerGitLabToolsForFastMCP(server, { toolFilter: filter });
```

--------------------------------

### Call GitLab REST API Directly (GET)

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/tools-overview.md

Use this tool to call any GitLab REST API endpoint directly. This example shows how to retrieve opened issues with specific labels.

```javascript
{
  "endpoint": "/projects/my-project/issues",
  "method": "GET",
  "params": {
    "state": "opened",
    "labels": "bug",
    "per_page": 10
  },
  "fields": ["id", "title", "labels"]
}
```

--------------------------------

### GitlabApiResponse Error Example

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/types.md

An example of an error response object from the GitLab API, indicating a failure such as a resource not found.

```json
{
  "error": true,
  "status": 404,
  "message": "GitLab API returned 404: resource not found",
  "details": { "message": "404 Not Found" }
}
```

--------------------------------

### Instantiate GitlabApiClient

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/api-client.md

Create a new GitlabApiClient instance with configuration including the GitLab base URL, private token, and optional timeout. Ensure GitlabConfig is imported.

```typescript
import { GitlabConfig } from './config/GitlabConfig';
import { GitlabApiClient } from './tools/gitlab/GitlabApiClient';

const config = new GitlabConfig({
  baseUrl: 'https://gitlab.com',
  privateToken: 'glpat-xxx...',
  timeout: 10000
});

const client = new GitlabApiClient(config);
```

--------------------------------

### Field Filtering for Performance

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/README.md

Example of using field filtering in a request to reduce response size.

```javascript
// Request
{ "fields": ["id", "name", "description"] }
```

--------------------------------

### Binary Entry Point

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/overview.md

Specifies the binary command for the mcp-server-gitlab package.

```json
bin["gitlab-mcp"] = "dist/index.js"
```

--------------------------------

### Create GitLab Client from Context

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/api-client.md

Creates a GitLab API client from MCP context, prioritizing token/URL from context session, then environment variables. Throws an error if authentication is missing.

```typescript
export function createGitlabClientFromContext(
  context?: Context<Record<string, unknown> | undefined>
): GitlabApiClient

import { createGitlabClientFromContext } from './utils/gitlabClientFactory';

async execute(args, context) {
  const client = createGitlabClientFromContext(context);
  const response = await client.apiRequest('/projects', 'GET');
  return response;
}
```

--------------------------------

### Response Field Filtering Example

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/README.md

Specify fields to filter in the request payload to reduce the size of the response.

```javascript
{
  "fields": ["id", "name", "owner.username", "items[0].id"]
}
```

--------------------------------

### MCP Error Response: Missing Authentication

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Example of an error response when a required GitLab token is missing from the request.

```bash
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {}
  }'
```

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32603,
    "message": "Internal error",
    "data": {
      "message": "GitLab token is required..."
    }
  }
}
```

--------------------------------

### GitlabApiClient Constructor

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/api-client.md

Creates a new GitLab API client instance with the provided configuration.

```APIDOC
## GitlabApiClient Constructor

### Description
Creates a new GitLab API client instance.

### Parameters
#### Path Parameters
- **config** (GitlabConfig) - Required - Configuration object with baseUrl, privateToken, and optional mappings

### Request Example
```typescript
import { GitlabConfig } from './config/GitlabConfig';
import { GitlabApiClient } from './tools/gitlab/GitlabApiClient';

const config = new GitlabConfig({
  baseUrl: 'https://gitlab.com',
  privateToken: 'glpat-xxx...',
  timeout: 10000
});

const client = new GitlabApiClient(config);
```
```

--------------------------------

### User and Project Mapping Configuration

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/errors.md

Configuration using environment variables to map user names or project names to their corresponding IDs, reducing the need for API calls to resolve them.

```bash
export GITLAB_USER_MAPPING='{"john": 123, "jane": 456}'
export GITLAB_PROJECT_MAPPING='{"backend": 789, "frontend": 790}'
```

--------------------------------

### Instantiate GitlabConfig with timeout

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/configuration.md

Example of setting a custom HTTP request timeout for GitlabConfig. The timeout is specified in milliseconds.

```typescript
// 30 second timeout
new GitlabConfig({ timeout: 30000 })
```

--------------------------------

### Available Tools

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/README.md

Lists and describes the 8 available tools for interacting with GitLab.

```APIDOC
## Available Tools (8)

This section lists and briefly describes the 8 tools provided by mcp-server-gitlab for interacting with GitLab functionalities.

1. **Gitlab_Search_User_Projects_Tool**: Search for projects associated with a user.
2. **Gitlab_Get_User_Tasks_Tool**: Retrieve a user's tasks or merge requests.
3. **Gitlab_Search_Project_Details_Tool**: Search for detailed information about projects.
4. **Gitlab_Create_MR_Tool**: Create a new merge request.
5. **Gitlab_Update_MR_Tool**: Update an existing merge request.
6. **Gitlab_Accept_MR_Tool**: Accept or merge a merge request.
7. **Gitlab_Create_MR_Comment_Tool**: Add a comment to a merge request.
8. **Gitlab_Raw_API_Tool**: Provides raw access to the GitLab API for custom operations.
```

--------------------------------

### Efficient Field Filtering Example

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/utilities.md

Illustrates efficient field filtering by specifying only needed fields to reduce payload size.

```json
{
  "endpoint": "/projects",
  "fields": ["id", "name", "web_url"]
}
```

--------------------------------

### createGitlabClientFromContext()

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/api-client.md

Creates a GitLab API client instance using the provided MCP context, automatically extracting authentication details from the session if available.

```APIDOC
## createGitlabClientFromContext()

### Description
Creates a GitLab API client from MCP context, extracting authentication from session if available.

### Function Signature
```typescript
export function createGitlabClientFromContext(
  context?: Context<Record<string, unknown> | undefined>
): GitlabApiClient
```

### Parameters
#### Path Parameters
- **context** (Context) - Optional - FastMCP context with optional session

### Returns
- **GitlabApiClient** - Configured client instance

### Priority for Authentication
1. Token/URL from context.session (HTTP headers in HTTP stream mode)
2. Token/URL from environment variables
3. Throws error if token is missing

### Example
```typescript
import { createGitlabClientFromContext } from './utils/gitlabClientFactory';

async execute(args, context) {
  const client = createGitlabClientFromContext(context);
  const response = await client.apiRequest('/projects', 'GET');
  return response;
}
```
```

--------------------------------

### MCP Protocol tools/call Error Response Format

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Example JSON-RPC 2.0 error response format for a tool call.

```json
{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Error message describing the failure"
      }
    ],
    "isError": true
  }
}
```

--------------------------------

### MCP Protocol tools/call Success Response Format

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Example JSON-RPC 2.0 success response format for a tool call.

```json
{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "{...JSON response...}"
      }
    ]
  }
}
```

--------------------------------

### Build GitLab MCP Server Docker Image

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/README.md

Builds a Docker image for the gitlab-mcp-server from the Dockerfile in the current directory.

```bash
docker build -t gitlab-mcp-server .
```

--------------------------------

### createGitlabClientFromContext(context?: Context<Record<string, unknown> | undefined>): GitlabApiClient

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/utilities.md

Creates a GitLab API client by extracting credentials from the provided MCP context session. It prioritizes session properties, then environment variables, and finally configuration defaults for authentication.

```APIDOC
## createGitlabClientFromContext(context?: Context<Record<string, unknown> | undefined>): GitlabApiClient

### Description
Creates GitLab API client from MCP context, extracting credentials from session.

### Parameters
- **context** (Context) - FastMCP context with session

### Returns
`GitlabApiClient` - Ready-to-use client

### Throws
Error if required credentials are missing

### Example
```typescript
import { createGitlabClientFromContext } from '@zephyr-mcp/gitlab/tools';

async execute(args, context) {
  const client = createGitlabClientFromContext(context);
  const projects = await client.apiRequest('/projects', 'GET');
  return projects;
}
```
```

--------------------------------

### Caching with ID Mappings

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/README.md

Use environment variables to map user and project names to their IDs for caching purposes.

```bash
export GITLAB_USER_MAPPING='{"john": 123, "jane": 456}'
export GITLAB_PROJECT_MAPPING='{"backend": 789}'
```

--------------------------------

### Get Available GitLab Tools

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/tools-overview.md

Retrieves an array of all available GitLab tool names. These names follow a standardized format.

```typescript
export function getAvailableGitLabTools(): GitLabToolName[]
```

```typescript
import { getAvailableGitLabTools } from '@zephyr-mcp/gitlab/tools';

const tools = getAvailableGitLabTools();
console.log(tools); // ['Gitlab_Search_User_Projects_Tool', ...]
```

--------------------------------

### Create GitLab Client from Context

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/utilities.md

Use this method within tools to create an authenticated GitLab client using credentials provided in the execution context. It falls back to environment variables if credentials are not found in headers.

```typescript
async execute(args, context) {
  const client = createGitlabClientFromContext(context);
  // Client is authenticated with credentials from context
  // Falls back to env vars if not in headers
}
```

--------------------------------

### MCP Error Response: Invalid Tool Name

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Example of an error response when the specified tool name is not found by the MCP server.

```bash
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer glpat-xxx" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "Invalid Tool Name",
      "arguments": {}
    }
  }'
```

```json
{
  "jsonrpc": "2.0",
  "id": 2,
  "error": {
    "code": -32603,
    "message": "Internal error",
    "data": {
      "message": "Tool 'Invalid Tool Name' not found"
    }
  }
}
```

--------------------------------

### Client Configuration with Bearer Token

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/README.md

Recommended client configuration using a Bearer token for authentication. Specifies the command to run the client CLI and includes the authorization header.

```json
{
  "mcpServers": {
    "@zephyr-mcp/gitlab": {
      "command": "npx",
      "args": [
        "@modelcontextprotocol/client-cli",
        "http://your-server:3000/mcp",
        "--header", "Authorization: Bearer your-gitlab-access-token"
      ]
    }
  }
}
```

--------------------------------

### MCP Error Response: API Error from Tool

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Example of an error response when a tool encounters an API error from GitLab, such as a non-existent user.

```bash
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer glpat-xxx" \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
      "name": "Gitlab Search User Projects Tool",
      "arguments": {
        "username": "nonexistent-user-xyz"
      }
    }
  }'
```

```json
{
  "jsonrpc": "2.0",
  "id": 3,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "User not found: nonexistent-user-xyz"
      }
    ],
    "isError": true
  }
}
```

--------------------------------

### Kubernetes Deployment Commands

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/server-integration.md

Commands to apply the Kubernetes deployment configuration and check the status of the deployed pods.

```bash
kubectl apply -f deployment.yaml
kubectl get pods -l app=gitlab-mcp
kubectl logs -f deployment/gitlab-mcp
```

--------------------------------

### isGitLabSession Type Guard Example

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/types.md

Demonstrates the usage of the isGitLabSession type guard to safely check if a session object is a GitLabSession and access its properties.

```typescript
if (isGitLabSession(context.session)) {
  console.log('Token:', context.session.gitlabToken);
}
```

--------------------------------

### Batch Operations with Sequential Requests

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/http-api.md

Demonstrates making individual requests sequentially for batch operations using Fetch API.

```javascript
const requests = [
  { id: 1, username: 'john' },
  { id: 2, username: 'jane' },
  { id: 3, username: 'bob' }
];

for (const req of requests) {
  const response = await fetch('http://localhost:3000/mcp', {
    method: 'POST',
    headers: { ... },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: req.id,
      method: 'tools/call',
      params: {
        name: 'Gitlab Search User Projects Tool',
        arguments: { username: req.username }
      }
    })
  });
  console.log(await response.json());
}
```

--------------------------------

### Create GitLab API Client

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/api-client.md

Creates a GitLab API client instance. It can be configured with an optional access token and base URL, falling back to environment variables if not provided. Use this to interact with the GitLab API.

```typescript
import { createGitlabApiClient } from './utils/gitlabClientFactory';

// Use environment variables
const client1 = createGitlabApiClient();

// Override with dynamic values
const client2 = createGitlabApiClient(
  'glpat-xxx...',
  'https://gitlab.company.com'
);

const response = await client2.apiRequest('/user', 'GET');
```

--------------------------------

### Instantiate GitlabConfig with allowEmptyBaseUrl

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/configuration.md

Example of enabling allowEmptyBaseUrl for GitlabConfig, typically used in HTTP stream mode where the base URL is provided per-request.

```typescript
// HTTP stream mode
new GitlabConfig({ allowEmptyBaseUrl: true })
```

--------------------------------

### FastMCP Context Interface Usage

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/_autodocs/types.md

Demonstrates how to use the FastMCP Context interface within tools. It shows access to session, logging, and other utilities.

```typescript
interface Context<T> {
  session: T;
  log: { debug, error, info, warn };
  reportProgress: (progress: number) => Promise<void>;
  streamContent: (content: any) => Promise<void>;
  client: McpClient;
}

async execute(args: unknown, context: Context<Record<string, unknown> | undefined>) {
  // Access session
  const client = createGitlabClientFromContext(context);
  
  // Use logging
  context.log.info('Processing request');
  
  // Stream large responses
  await context.streamContent(largeData);
}

```

--------------------------------

### Client Configuration with Dynamic GitLab URL and Token

Source: https://github.com/zephyrdeng/mcp-server-gitlab/blob/master/README.md

Client configuration that allows specifying a dynamic GitLab URL along with the access token. Includes both Authorization and x-gitlab-url headers.

```json
{
  "mcpServers": {
    "@zephyr-mcp/gitlab": {
      "command": "npx",
      "args": [
        "@modelcontextprotocol/client-cli",
        "http://your-server:3000/mcp",
        "--header", "Authorization: Bearer your-gitlab-access-token",
        "--header", "x-gitlab-url: https://gitlab.company.com"
      ]
    }
  }
}
```
Tokens:
Raw