Which integrations are available for this server?

Provides comprehensive integration with Qlik Sense, enabling AI assistants to list applications, retrieve measures, variables, fields, sheets, visualization objects, dimensions, scripts, and data sources from Qlik Sense Enterprise through WebSocket connections with certificate-based authentication.

How do I use Qlik MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Qlik MCP Server list all applications with metadata" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Qlik MCP Server

by arthurfantaci

Overview Schema Related Servers Score Discussions

Python

Remote

Qlik MCP Server

Python License MCP

A comprehensive MCP (Model Context Protocol) server that provides complete access to Qlik Sense applications and their detailed information for AI assistants and other MCP clients.

Features

🔌 Direct WebSocket connection to Qlik Sense Enterprise
🔐 Certificate-based authentication with SSL security
📦 VizlibContainer support with embedded object extraction
🔗 Master Item resolution automatically resolves references to full expressions
🔍 BINARY LOAD detection automatically extracts and analyzes BINARY dependencies
📊 Advanced Script Analysis with section parsing, variable extraction, and statement counting
📊 9 comprehensive tools covering all major Qlik Sense objects:
- 📋 List all available applications with metadata
- 📊 Retrieve measures with expressions and tags
- 🔧 Retrieve variables with definitions and configurations
- 📊 Retrieve fields and complete data model information
- 📄 Retrieve sheets with metadata and properties
- 🎨 Retrieve visualization objects from sheets with detailed properties
- 📐 Retrieve dimensions with grouping and metadata
- 📜 Retrieve and analyze data loading scripts with BINARY LOAD extraction
- 🔗 Retrieve data sources and lineage information
🤖 MCP-compatible for use with Claude Desktop and other AI tools
⚡ Production-ready with comprehensive error handling
🧪 Extensively tested with real Qlik Sense applications

Related MCP server: Metabase MCP Plus

Why This Matters

🎯 Business Impact: This MCP server bridges the gap between Qlik Sense's powerful analytics and modern AI assistants, enabling:

10x faster insights - Natural language queries replace complex Qlik Sense expressions
Democratized analytics - Non-technical users can explore Qlik data through conversation
Automated documentation - AI can instantly analyze and document your entire Qlik application structure
Enterprise-ready integration - Production-grade WebSocket connections with certificate-based security

💡 Use Cases:

Automated QA: AI assistants can validate measures, dimensions, and data models
Documentation Generation: Automatically create comprehensive app documentation
Migration Analysis: Assess complexity before Qlik app migrations or upgrades
Governance Auditing: Review variables, scripts, and data sources for compliance

🛠️ Modern Development Stack

This project uses industry-standard tools for reliability and maintainability:

🚀 UV: Fast, reliable Python package management and virtual environment handling
🧹 Ruff: Lightning-fast Python linter and formatter with automated code quality
🧪 Pytest: Professional testing framework with unit/integration test separation
🤖 GitHub Actions: Automated CI/CD with matrix testing across Python versions
📦 FastMCP: Modern MCP server framework with Pydantic validation

Prerequisites

Python 3.10+ (required for FastMCP)
UV package manager (strongly recommended - handles everything automatically)
Access to Qlik Sense Enterprise server
Valid Qlik client certificates (see Certificate Setup Guide)
MCP-compatible client (e.g., Cursor IDE, VS Code, Claude Desktop)

Quick Start

1. Installation

# Clone the repository
git clone https://github.com/arthurfantaci/qlik-mcp-server.git
cd qlik-mcp-server

# Install with UV (strongly recommended)
curl -LsSf https://astral.sh/uv/install.sh | sh  # Install UV if not already installed
uv sync  # Creates virtual environment and installs all dependencies automatically

Why UV? UV provides faster, more reliable dependency management with automatic virtual environment handling, lockfile generation for reproducible builds, and seamless integration with modern Python development workflows.

2. Configuration

# Copy the example environment file
cp .env.example .env

# Edit .env with your Qlik Sense server details
# See .env.example for detailed configuration instructions

3. Certificate Setup

Obtain SSL certificates from your Qlik Sense administrator and place them in the certs/ directory:

certs/
├── root.pem          # Server root certificate
├── client.pem        # Client certificate  
└── client_key.pem    # Client private key

📖 Detailed certificate setup instructions: docs/CERTIFICATES.md

4. Test Connection

# Test basic Qlik connection
uv run pytest tests/test_qlik_connection.py -v

# Test application listing
uv run pytest tests/test_list_apps.py -v

# Run all unit tests (no Qlik server required)
uv run pytest -m unit

# Run integration tests (requires Qlik server)
uv run pytest -m integration

5. Configure with Cursor IDE

# For project-specific configuration (recommended)
mkdir -p .cursor
cp examples/cursor_config.json .cursor/mcp.json

# OR for global configuration
cp examples/cursor_config.json ~/.cursor/mcp.json

# Update the paths in the configuration to match your setup
# Enable MCP in Cursor Settings and restart Cursor

6. Configure with VS Code

# Copy example configuration to VS Code settings
cp examples/vscode_config.json ~/.vscode/settings.json

# Or merge with existing VS Code settings
# Update the paths in the configuration to match your setup

7. Configure with Claude Desktop

# Copy example configuration to Claude Desktop
cp examples/claude_desktop_config.json ~/.config/claude_desktop_config.json

# Edit the configuration file to update paths
# Then restart Claude Desktop

📖 Detailed configuration examples: examples/README.md

Usage

Running as MCP Server

Start the MCP server:

# Using Python 3.11 (recommended)
/opt/homebrew/bin/python3.11 -m src.server

# Or using the startup script
/opt/homebrew/bin/python3.11 start_server.py

Available Tools

The server provides 9 comprehensive tools for Qlik Sense analysis:

Tool	Description
`list_qlik_applications`	List all available applications with metadata
`get_app_measures`	Retrieve measures with expressions and tags
`get_app_variables`	Retrieve variables with definitions and configurations
`get_app_fields`	Retrieve fields and complete data model information
`get_app_sheets`	Retrieve sheets with metadata and properties
`get_sheet_objects`	Retrieve visualization objects with detailed properties
`get_app_dimensions`	Retrieve dimensions with grouping and metadata
`get_app_script`	Retrieve and analyze scripts with BINARY LOAD extraction
`get_app_data_sources`	Retrieve data sources and lineage information

Enhanced Script Tool Examples

The get_app_script tool now includes powerful analysis capabilities. Here are examples of how to use it:

Basic Script Retrieval

"Get the script from app 12345678-abcd-1234-efgh-123456789abc"

Script with Full Analysis and BINARY LOAD Detection

"Analyze the script from app 12345678-abcd-1234-efgh-123456789abc and show me all BINARY LOAD statements"

Parameters used:
- analyze_script: true
- Result includes: BINARY LOAD statements with source apps, variable declarations, statement counts

Script with Section Parsing

"Get the script from app 12345678-abcd-1234-efgh-123456789abc and break it down by sections"

Parameters used:
- include_sections: true  
- Result: Script organized by ///$tab sections with line ranges

Script Preview with Line Numbers

"Show me the first 1000 characters of the script from app 12345678-abcd-1234-efgh-123456789abc with line numbers"

Parameters used:
- max_preview_length: 1000
- include_line_numbers: true
- Result: Truncated script with line numbers for easy reference

Complete Analysis with All Features

"Perform a comprehensive analysis of the script from app 12345678-abcd-1234-efgh-123456789abc including BINARY LOAD detection, sections, and show line numbers"

Parameters used:
- analyze_script: true
- include_sections: true  
- include_line_numbers: true
- Result: Full analysis with BINARY LOAD extraction, sections, variables, and formatted output

Script Analysis Response Includes:

Total lines, empty lines, comment lines
Script sections/tabs with line ranges
BINARY LOAD statements with source applications and line numbers
Count of LOAD, STORE, DROP statements
SET and LET variable declarations
Connection strings (sanitized)
Include file references
Subroutine definitions

📚 Complete Script Tool Usage Guide - Comprehensive documentation with all parameters and advanced examples

Using with Different MCP Clients

Cursor IDE

Important: Switch to Agent Mode (not Ask Mode) to access MCP tools
Tools are available through natural language commands
Cursor will ask for permission before executing tools (configurable in settings)
Example: "Use the Qlik tools to list all available applications"

VS Code

Access tools through the MCP extension
Use the command palette or natural language interface
Tools execute with appropriate permissions

Claude Desktop

Once configured, you can use natural language to access all tools:

🔍 Explore Applications:

"Show me all available Qlik Sense applications"

📊 Analyze Measures:

"Get all measures from Qlik app 12345678-abcd-1234-efgh-123456789abc with expressions and tags"

🔧 Review Variables:

"Show me all variables in the application including their definitions"

📊 Examine Data Model:

"Get all fields and table information to understand the data model structure"

📄 Review Sheets:

"List all sheets in the application with their metadata"

🎨 Analyze Visualizations:

"Get all visualization objects from sheet 'Overview' with their properties and layout"

📐 Study Dimensions:

"Show me all dimensions with their grouping and metadata information"

📜 Review Data Loading:

"Get the complete data loading script for this application"

🔗 Understand Data Sources:

"Show me all data sources and their lineage, including binary and file sources"

The measures tool will return:

Measure IDs and titles
Measure descriptions
Expressions (optional)
Tags (optional)
Total count of measures

The applications list tool will return:

Application names and IDs
Last reload timestamps
Total count of applications

The variables tool will return:

Variable names and definitions
Variable tags (optional)
Reserved and configuration flags
Total count of variables

The fields tool will return:

Field names and properties (numeric, system, hidden, etc.)
Source table information for each field
Complete list of tables in the application
Field cardinality and tags
Data model structure for analysis

The sheets tool will return:

Sheet IDs and titles
Sheet descriptions and metadata
Layout information (columns, rows)
Publication status and creation dates
Total count of sheets

The sheet objects tool will return:

Visualization object IDs and types
Object titles and subtitles
Position and sizing information
Object properties and layout details
Dimension and measure configurations with Master Item resolution
VizlibContainer objects with embedded visualizations
Container structure with tabs/panels and nested objects
Total count of objects on the sheet

The dimensions tool will return:

Dimension IDs and titles
Dimension descriptions and definitions
Field definitions and labels
Grouping information and hierarchy
Tags and metadata
Total count of dimensions

The script tool will return:

Complete data loading script content
Script length in characters
All LOAD statements and transformations
Data connection strings and sources
Variable definitions and SET statements

The data sources tool will return:

Data source names and types
Connection strings and statements
Source categorization (file, binary, resident, inline)
Source counts by type
Lineage and dependency information
Total count of all data sources

Tool Parameters

`get_app_measures` Tool

Parameter	Type	Required	Description
`app_id`	string	Yes	Qlik Sense application ID
`include_expression`	boolean	No	Include measure expressions (default: true)
`include_tags`	boolean	No	Include measure tags (default: true)

`list_qlik_applications` Tool

Parameter	Type	Required	Description
(no parameters)	-	-	Returns all available applications

`get_app_variables` Tool

Parameter	Type	Required	Description
`app_id`	string	Yes	Qlik Sense application ID
`include_definition`	boolean	No	Include variable definitions (default: true)
`include_tags`	boolean	No	Include variable tags (default: true)
`show_reserved`	boolean	No	Include reserved system variables (default: true)
`show_config`	boolean	No	Include configuration variables (default: true)

`get_app_fields` Tool

Parameter	Type	Required	Description
`app_id`	string	Yes	Qlik Sense application ID
`show_system`	boolean	No	Include system fields (default: true)
`show_hidden`	boolean	No	Include hidden fields (default: true)
`show_derived_fields`	boolean	No	Include derived fields (default: true)
`show_semantic`	boolean	No	Include semantic fields (default: true)
`show_src_tables`	boolean	No	Include source table information (default: true)
`show_implicit`	boolean	No	Include implicit fields (default: true)

`get_app_sheets` Tool

Parameter	Type	Required	Description
`app_id`	string	Yes	Qlik Sense application ID
`include_thumbnail`	boolean	No	Include sheet thumbnail images (default: false)
`include_metadata`	boolean	No	Include detailed metadata (default: true)

`get_sheet_objects` Tool

Parameter	Type	Required	Description
`app_id`	string	Yes	Qlik Sense application ID
`sheet_id`	string	Yes	Sheet ID to retrieve objects from
`include_properties`	boolean	No	Include object properties (default: true)
`include_layout`	boolean	No	Include object layout information (default: true)
`include_data_definition`	boolean	No	Include measure/dimension definitions (default: true)
`resolve_master_items`	boolean	No	Resolve Master Item references to full expressions (default: true)

`get_app_dimensions` Tool

Parameter	Type	Required	Description
`app_id`	string	Yes	Qlik Sense application ID
`include_title`	boolean	No	Include dimension titles (default: true)
`include_tags`	boolean	No	Include dimension tags (default: true)
`include_grouping`	boolean	No	Include grouping information (default: true)
`include_info`	boolean	No	Include additional metadata (default: true)

`get_app_script` Tool

Parameter	Type	Required	Description
`app_id`	string	Yes	Qlik Sense application ID
`analyze_script`	boolean	No	Enable comprehensive script analysis including BINARY LOAD extraction (default: false)
`include_sections`	boolean	No	Parse script into sections/tabs based on ///$tab markers (default: false)
`include_line_numbers`	boolean	No	Add line numbers to script output (default: false)
`max_preview_length`	integer	No	Maximum characters to return for script preview (minimum: 100)

`get_app_data_sources` Tool

Parameter	Type	Required	Description
`app_id`	string	Yes	Qlik Sense application ID
`include_resident`	boolean	No	Include resident table sources (default: true)
`include_file_sources`	boolean	No	Include file-based sources (default: true)
`include_binary_sources`	boolean	No	Include binary load sources (default: true)
`include_inline_sources`	boolean	No	Include inline data sources (default: true)

Response Formats

`get_app_measures` Response

{
  "app_id": "12345678-abcd-1234-efgh-123456789abc",
  "measures": [
    {
      "id": "measure_id",
      "title": "Revenue",
      "description": "Total revenue calculation",
      "expression": "Sum(Sales)",
      "label": "Total Revenue",
      "tags": ["finance", "kpi"]
    }
  ],
  "count": 25,
  "retrieved_at": "2025-08-29T10:30:00Z",
  "options": {
    "include_expression": true,
    "include_tags": true
  }
}

`list_qlik_applications` Response

{
  "applications": [
    {
      "app_id": "12345678-abcd-1234-efgh-123456789abc",
      "name": "CRM Dashboard",
      "last_reload_time": "2025-08-29T10:30:00Z",
      "meta": {},
      "doc_type": ""
    }
  ],
  "count": 50,
  "retrieved_at": "2025-08-29T10:30:00Z"
}

`get_app_variables` Response

{
  "app_id": "12345678-abcd-1234-efgh-123456789abc",
  "variables": [
    {
      "name": "vDataSource",
      "definition": "dev",
      "tags": [],
      "is_reserved": false,
      "is_config": false
    }
  ],
  "count": 25,
  "retrieved_at": "2025-08-29T10:30:00Z",
  "options": {
    "include_definition": true,
    "include_tags": true,
    "show_reserved": true,
    "show_config": true
  }
}

`get_app_fields` Response

{
  "app_id": "12345678-abcd-1234-efgh-123456789abc",
  "fields": [
    {
      "name": "customer_id",
      "source_tables": ["fact_crm", "dim_customer"],
      "is_system": false,
      "is_hidden": false,
      "is_numeric": true,
      "cardinal": 4818662,
      "tags": ["$key", "$numeric", "$integer"]
    }
  ],
  "tables": [
    "fact_transactions",
    "dim_customer_details"
  ],
  "field_count": 60,
  "table_count": 10,
  "retrieved_at": "2025-08-29T10:30:00Z",
  "options": {
    "show_system": true,
    "show_hidden": true,
    "show_derived_fields": true,
    "show_semantic": true,
    "show_src_tables": true,
    "show_implicit": true
  }
}

`get_app_sheets` Response

{
  "app_id": "12345678-abcd-1234-efgh-123456789abc",
  "sheets": [
    {
      "id": "sheet_abc123",
      "title": "Summary View",
      "description": "Summary of OKRs",
      "rank": 0,
      "columns": 14,
      "rows": 10,
      "meta": {
        "created": "2025-08-15T09:00:00Z",
        "modified": "2025-08-29T10:30:00Z",
        "published": true
      }
    }
  ],
  "count": 5,
  "retrieved_at": "2025-08-29T10:30:00Z",
  "options": {
    "include_thumbnail": false,
    "include_metadata": true
  }
}

`get_sheet_objects` Response

{
  "app_id": "12345678-abcd-1234-efgh-123456789abc",
  "sheet_id": "sheet_abc123",
  "objects": [
    {
      "id": "object_xyz789",
      "type": "barchart",
      "title": "Sales by Region",
      "subtitle": "Last 12 months",
      "position": {
        "x": 0,
        "y": 0,
        "width": 12,
        "height": 6
      },
      "properties": {
        "dimensions": ["Region"],
        "measures": ["Sum(Sales)"],
        "color": {
          "auto": true
        }
      },
      "layout": {
        "visualization": "barchart",
        "version": "1.0"
      }
    }
  ],
  "count": 12,
  "retrieved_at": "2025-08-29T10:30:00Z",
  "options": {
    "include_properties": true,
    "include_layout": true,
    "include_data_definition": true,
    "resolve_master_items": true
  }
}

`get_app_dimensions` Response

{
  "app_id": "12345678-abcd-1234-efgh-123456789abc",
  "dimensions": [
    {
      "id": "dim_product_category",
      "title": "Product Category",
      "description": "Product categorization hierarchy",
      "grouping": "N",
      "field_defs": ["Category"],
      "field_labels": ["Product Category"],
      "tags": ["product", "hierarchy"],
      "meta": {
        "created": "2025-08-10T14:30:00Z",
        "approved": true
      }
    }
  ],
  "count": 30,
  "retrieved_at": "2025-08-29T10:30:00Z",
  "options": {
    "include_title": true,
    "include_tags": true,
    "include_grouping": true,
    "include_info": true
  }
}

`get_app_script` Response

{
  "app_id": "12345678-abcd-1234-efgh-123456789abc",
  "script": "// Main data loading script\n\n// Load sales data\nSales:\nLOAD\n    OrderID,\n    CustomerID,\n    ProductID,\n    Quantity,\n    UnitPrice,\n    OrderDate\nFROM [lib://DataFiles/sales.qvd] (qvd);\n\n// Load customer data\nCustomers:\nLOAD\n    CustomerID,\n    CustomerName,\n    Region,\n    Country\nFROM [lib://DataFiles/customers.xlsx]\n(ooxml, embedded labels, table is Customers);\n",
  "script_length": 245,
  "retrieved_at": "2025-08-29T10:30:00Z"
}

`get_app_data_sources` Response

{
  "app_id": "12345678-abcd-1234-efgh-123456789abc",
  "data_sources": [
    {
      "name": "sales.qvd",
      "type": "file",
      "connection_string": "lib://DataFiles/sales.qvd",
      "statement": "LOAD * FROM [lib://DataFiles/sales.qvd] (qvd);",
      "discrimination": {
        "type": "DataConnection",
        "label": "QVD file source"
      }
    },
    {
      "name": "CustomerAnalytics.qvf",
      "type": "binary",
      "connection_string": "lib://Apps/CustomerAnalytics.qvf",
      "statement": "binary [lib://Apps/CustomerAnalytics.qvf];",
      "discrimination": {
        "type": "BinaryLoad",
        "label": "Binary application load"
      }
    },
    {
      "name": "TempTable",
      "type": "resident",
      "connection_string": "Resident SalesData",
      "statement": "LOAD CustomerID, Sum(Amount) as TotalSales RESIDENT SalesData GROUP BY CustomerID;",
      "discrimination": {
        "type": "ResidentLoad",
        "label": "Resident table transformation"
      }
    }
  ],
  "source_counts": {
    "binary": 1,
    "file": 3,
    "resident": 8,
    "inline": 1,
    "other": 0
  },
  "total_sources": 13,
  "retrieved_at": "2025-08-29T10:30:00Z",
  "options": {
    "include_resident": true,
    "include_file": true,
    "include_binary": true,
    "include_inline": true
  }
}

Project Structure

qlik-mcp-server/
├── .github/workflows/      # CI/CD automation
│   └── test.yml           # GitHub Actions test pipeline
├── .claude/                # Claude Code configuration
│   └── settings.local.json # Local Claude settings
├── src/                    # Core application code
│   ├── __init__.py         # Package initialization
│   ├── server.py           # FastMCP server implementation
│   ├── qlik_client.py      # Qlik Engine API WebSocket client
│   └── tools.py            # MCP tool definitions and implementations
├── tests/                  # Comprehensive test suite (pytest)
│   ├── conftest.py         # Pytest configuration and fixtures
│   ├── README.md           # Testing documentation and guidelines
│   ├── test_qlik_connection.py    # Test basic connection
│   ├── test_list_apps.py          # Test application listing
│   ├── test_mcp_tool.py           # Test MCP tool functions (includes measures)
│   ├── test_variables.py          # Test variable retrieval
│   ├── test_fields.py             # Test field retrieval
│   ├── test_sheets.py             # Test sheet retrieval
│   ├── test_dimensions.py         # Test dimension retrieval
│   ├── test_script.py             # Test script retrieval and analysis
│   ├── test_data_sources.py       # Test data source retrieval
│   ├── test_binary_extraction.py  # Test BINARY LOAD extraction
│   ├── test_vizlib_container.py   # Test VizlibContainer functionality
│   └── test_both_tools.py         # Test multiple tools together
├── examples/               # Configuration examples
│   ├── cursor_config.json         # Cursor IDE configuration
│   ├── vscode_config.json         # VS Code configuration
│   ├── claude_desktop_config.json # Claude Desktop configuration
│   └── README.md           # Configuration instructions
├── docs/                   # Documentation
│   ├── CERTIFICATES.md     # Certificate setup guide
│   ├── API_REFERENCE.md    # Complete API documentation
│   ├── SCRIPT_TOOL_USAGE.md # Script tool usage guide
│   └── TROUBLESHOOTING.md  # Troubleshooting guide
├── certs/                  # SSL certificates (gitignored)
│   ├── root.pem           # Server root certificate
│   ├── client.pem         # Client certificate
│   └── client_key.pem     # Client private key
├── .env.example           # Example environment configuration
├── .env.test.example      # Test environment configuration template
├── .env                   # Environment configuration (gitignored)
├── .gitignore            # Git ignore rules
├── pyproject.toml         # Python project configuration and dependencies
├── pytest.ini            # Pytest configuration and markers
├── uv.lock               # UV dependency lockfile for reproducible builds
├── start_server.py       # Server startup script
├── CLAUDE.md             # Claude Code instructions
├── CONTRIBUTING.md       # Contribution guidelines
├── LICENSE               # MIT license
└── README.md             # This documentation

Security

Certificate files are excluded from version control via .gitignore
Never commit .env files or certificates to repositories
Use environment variables for sensitive configuration
Certificates should be properly secured with appropriate file permissions

Troubleshooting

Connection Issues

Certificate errors: Verify certificates are in PEM format and readable
Authentication fails: Check QLIK_USER_DIRECTORY and QLIK_USER_ID settings
Timeout errors: Increase WEBSOCKET_TIMEOUT in .env
App not found: Verify app ID and user permissions in QMC

MCP Issues

Server won't start: Check Python version (3.10+ required)
Tool not found: Restart Claude Desktop after configuration changes
No response: Check server logs for errors

Development

Running Tests

The project uses pytest exclusively for professional-grade testing with clear separation between unit and integration tests.

Setup Test Environment

# Install test dependencies (automatically handled by UV)
uv sync  # Installs both main and dev dependencies including pytest

# Configure test environment for integration tests
cp .env.test.example .env.test
# Edit .env.test with your Qlik server details (when available)

Pytest Testing Commands

# Run all tests
uv run pytest

# Run with verbose output
uv run pytest -v

# Run only unit tests (no Qlik server required - perfect for development)
uv run pytest -m unit

# Run integration tests (requires Qlik server connection)
uv run pytest -m integration

# Run with coverage report
uv run pytest --cov=src --cov-report=html

# Run specific test file
uv run pytest tests/test_mcp_tool.py

# Run specific test function
uv run pytest tests/test_mcp_tool.py::test_get_app_measures_mock

Test Categories

The test suite uses pytest markers for clear organization:

@pytest.mark.unit: Fast tests that don't require external dependencies
@pytest.mark.integration: Tests requiring live Qlik Sense server connection
@pytest.mark.slow: Long-running tests (can be excluded with -m "not slow")

Pro Tip: Use uv run pytest -m unit during development for fast feedback loops, then run integration tests when you have Qlik server access.

Test Specific Functionality

# Test specific components with pytest
uv run pytest tests/test_mcp_tool.py -v           # MCP tool functions (includes measures)
uv run pytest tests/test_variables.py -v          # Variable retrieval
uv run pytest tests/test_fields.py -v             # Field and table information
uv run pytest tests/test_sheets.py -v             # Sheet metadata
uv run pytest tests/test_dimensions.py -v         # Dimension analysis
uv run pytest tests/test_script.py -v             # Script retrieval and analysis
uv run pytest tests/test_data_sources.py -v       # Data source lineage
uv run pytest tests/test_binary_extraction.py -v  # BINARY LOAD extraction
uv run pytest tests/test_vizlib_container.py -v   # VizlibContainer functionality
uv run pytest tests/test_both_tools.py -v         # Multiple tools together

# Debug Qlik client directly
uv run python -m src.qlik_client

See tests/README.md for comprehensive testing documentation.

Code Quality & Formatting

The project maintains high code quality standards with automated tooling:

# Run Ruff linting and formatting
uv run ruff check                    # Check for style and quality issues
uv run ruff check --fix              # Auto-fix issues where possible
uv run ruff format                   # Format code according to standards

# The project is configured with:
# - pyproject.toml: Ruff configuration for consistent code style
# - Automatic import sorting and code formatting
# - Integration with development workflow

Continuous Integration (CI/CD)

The project includes a comprehensive GitHub Actions workflow (.github/workflows/test.yml) that automatically:

🔄 Automated Testing:

Runs on every push to main and develop branches
Executes on all pull requests
Matrix testing across multiple Python versions (3.10, 3.11, 3.12, 3.13)
Separate unit test and integration test execution

🛠️ Quality Assurance:

UV dependency management and caching
Ruff linting and formatting verification
Pytest execution with coverage reporting
Test result reporting and failure notifications

🚀 Manual Triggers:

Workflow can be manually triggered via GitHub Actions UI
Optional integration test execution (when Qlik server access is available)

The CI/CD pipeline ensures code quality and prevents regressions, making the project reliable for production use.

Adding New Tools

To add more Qlik tools:

Define a Pydantic model in tools.py for parameter validation with Field annotations
Implement the tool function in tools.py
Register the tool in server.py using @mcp.tool() accepting the Pydantic model
FastMCP automatically generates schemas from Pydantic models

Tool Definitions

The server provides 9 comprehensive tools for complete Qlik Sense analysis. See the main tools table above for complete details and parameters.

Limitations

Current implementation considerations:

Single app connection at a time
No retry logic for failed connections
Basic error handling
No caching of results
Sequential processing only
Minimal logging

Future Enhancements

The project has achieved a modern, production-ready foundation. Potential enhancements:

📈 Scalability & Performance:

Connection pooling for multiple concurrent app connections
Intelligent caching of frequently accessed data
WebSocket reconnection handling with retry logic

🔧 Additional Functionality:

Tools for additional Qlik objects (bookmarks, stories, etc.)
Advanced filtering and pagination for large datasets
Bulk operations for enterprise-scale deployments

🔍 Observability & Monitoring:

Structured logging with configurable levels
Performance metrics and monitoring endpoints
Distributed tracing for complex operations

Note: The core development infrastructure (UV, Ruff, Pytest, GitHub Actions) is already enterprise-ready, providing a solid foundation for these future enhancements.

Recent Enhancements

Script Tool v2.0 (Latest)

✨ BINARY LOAD Detection: Automatically extracts all BINARY LOAD statements with source applications
📑 Section Parsing: Organizes scripts by ///$tab markers with line ranges
📊 Comprehensive Analysis: Statement counting, variable extraction, connection detection
🔒 Security Enhancements: Automatic password and credential sanitization
📏 Line Numbering: Optional line numbers for easy reference
✂️ Script Preview: Configurable truncation for large scripts
📚 Enhanced Documentation: Complete usage guide with examples

License

This project is licensed under MIT. Ensure compliance with your organization's Qlik Sense licensing terms.

Support

For technical support:

Check the troubleshooting section
Verify Qlik server connectivity
Review server logs for detailed error messages
Ensure certificates are valid and not expired

Available Tools

9 tools

handle_get_app_data_sourcesA

MCP tool handler for retrieving data sources from a Qlik Sense application.

This tool connects to a Qlik Sense server, opens the specified application, retrieves the lineage information to identify all data sources used in LOAD and STORE statements, and returns categorized results for analysis.

ParametersJSON Schema

Name	Required	Description	Default
`args`	Yes	Retrieve data sources from a Qlik Sense application's lineage. This tool connects to a Qlik Sense server, opens the specified application, retrieves the lineage information to identify all data sources used in LOAD and STORE statements, and returns categorized results for analysis.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description bears full responsibility. It discloses it connects to a server, opens an app, retrieves lineage, and returns categorized results. It does not mention side effects, authentication requirements, or performance considerations, but as a read operation the transparency is adequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the purpose, and contains no extraneous information. Every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given moderate parameter count (5), required fields (1), and presence of an output schema, the description provides sufficient context. It mentions 'categorized results' which is appropriate since the output schema presumably details categories. The tool's complexity is well-covered.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, and the description adds minimal value beyond what the input schema already provides. The description reiterates 'lineage information to identify all data sources' but does not elaborate on parameter usage beyond the schema's own descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('retrieves'), resource ('data sources from Qlik Sense application'), and scope ('LOAD and STORE statements'). It distinguishes from siblings (e.g., handle_get_app_dimensions, handle_get_app_fields) by focusing specifically on data sources.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage when needing to identify data sources, but does not explicitly state when not to use it or compare to alternatives. However, sibling tool names provide enough context that this tool is for data sources, not other application components.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

handle_get_app_dimensionsA

MCP tool handler for retrieving dimensions from a Qlik Sense application.

This tool connects to a Qlik Sense server, opens the specified application, retrieves all dimensions with their metadata and configuration details, and returns the results as structured JSON for analysis.

ParametersJSON Schema

Name	Required	Description	Default
`args`	Yes	Retrieve all dimensions from a Qlik Sense application. This tool connects to a Qlik Sense server, opens the specified application, retrieves all dimensions with their metadata and configuration details, and returns the results as structured JSON for analysis.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description must disclose behavioral traits. It covers connecting to server, opening app, retrieving dimensions, and returning JSON. However, it does not mention authentication needs, rate limits, or whether the operation is read-only.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the main action, and contains no filler. Every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of an output schema and the simple retrieval nature, the description adequately explains the tool's purpose. It lacks mention of error handling or performance, but these are not critical for a read operation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with each parameter described. The tool description adds no extra meaning beyond the schema, so a baseline score of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves dimensions from a Qlik Sense application with metadata, distinguishing it from sibling tools like fields, measures, etc.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It describes what the tool does but does not explicitly state when to use it versus alternatives like get_app_fields or get_app_measures. Usage is implied by the name and sibling context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

handle_get_app_fieldsA

MCP tool handler for retrieving Qlik Sense fields and table information.

This tool connects to a Qlik Sense server, opens the specified application, creates a FieldList session object, retrieves all field metadata and table information, and returns the results as structured JSON for data model analysis.

ParametersJSON Schema

Name	Required	Description	Default
`args`	Yes	Retrieve all fields and table information from a Qlik Sense application. This tool connects to a Qlik Sense server, opens the specified application, creates a FieldList session object, retrieves all field metadata and table information, and returns the results as structured JSON for data model analysis.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A3.7/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations are absent, so the description must disclose behavioral traits. It mentions connecting to a server and creating session objects but does not specify if the operation is read-only, required permissions, rate limits, or potential side effects. The description is acceptable but lacks key behavioral context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise with two sentences, efficiently summarizing the tool's purpose and workflow. The first sentence is slightly redundant ('MCP tool handler for...') but not overly verbose. Well-structured for quick understanding.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the existence of an output schema (not shown) and full schema descriptions for parameters, the description provides sufficient context for an AI agent to understand the tool's purpose and mechanism. However, it could mention that the tool does not modify data and that the boolean parameters filter results.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage for all parameters. The tool description does not add additional meaning beyond what is already in the schema (e.g., it does not elaborate on the boolean toggles or the app_id format). Baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it retrieves Qlik Sense fields and table information, specifying the exact actions (connects, opens app, creates FieldList, retrieves metadata, returns JSON). It distinguishes from sibling tools which focus on other app components like dimensions or measures.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not explicitly state when to use this tool vs alternatives. It only describes functionality, leaving usage context implied (e.g., when field and table info is needed). No exclusion criteria or alternative tool references are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

handle_get_app_measuresA

MCP tool handler for retrieving Qlik Sense measures.

This tool connects to a Qlik Sense server, opens the specified application, creates a MeasureList session object, retrieves all measure metadata, and returns the results as structured JSON.

ParametersJSON Schema

Name	Required	Description	Default
`args`	Yes	Retrieve all measures from a Qlik Sense application. This tool connects to a Qlik Sense server, opens the specified application, creates a MeasureList session object, retrieves all measure metadata, and returns the results as structured JSON.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A3.5/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description minimally describes the retrieval process (connects, opens, creates, retrieves, returns) but does not disclose potential side effects, authentication needs, or performance implications. It is accurate but lacks depth.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two concise sentences with no wasted words. The first sentence front-loads the purpose, and the second adds procedural context. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description adequately conveys the core action but omits mention of optional parameters that control response content (include_expression, include_tags). However, since the schema covers these, the description is minimally complete for the main task.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema covers all parameters with clear descriptions (app_id as GUID/name, include_expression and include_tags with defaults). The tool description adds no additional meaning beyond the schema, so the baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'retrieving' and the resource 'Qlik Sense measures', distinguishing it from sibling tools for other app resources like data sources, dimensions, fields, etc.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide any guidance on when to use this tool versus alternatives, nor does it mention any context or exclusions. It only describes what the tool does, leaving the agent to infer usage from the tool name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

handle_get_app_scriptA

MCP tool handler for retrieving and analyzing the script from a Qlik Sense application.

This tool connects to a Qlik Sense server, opens the specified application, retrieves the complete application script used for data loading and transformation, optionally performs detailed analysis including BINARY LOAD extraction, and returns it as structured JSON.

ParametersJSON Schema

Name	Required	Description	Default
`args`	Yes	Retrieve and optionally analyze the script from a Qlik Sense application. This tool connects to a Qlik Sense server, opens the specified application, retrieves the complete application script used for data loading and transformation, optionally performs detailed analysis including BINARY LOAD extraction, and returns it as structured JSON.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A3.6/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It outlines the process (connect, open, retrieve, optionally analyze, return JSON) but lacks details on side effects, permissions, rate limits, or error handling.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single paragraph that front-loads the purpose and is reasonably concise, though slightly verbose with redundant phrasing like 'retrieving and analyzing' appearing twice.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity and the presence of a output schema, the description covers basic functionality but omits important contextual details such as authentication requirements, error conditions, or the structure of the returned JSON.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema coverage is 100%, with each parameter having a description. The tool description adds minimal additional meaning beyond these schema descriptions, so baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it retrieves and optionally analyzes the Qlik Sense application script, distinguishing it from sibling tools that handle other aspects like data sources, dimensions, or sheets.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use for script retrieval and analysis, but does not explicitly state when to use this tool versus alternatives, nor provides when-not-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

handle_get_app_sheetsA

MCP tool handler for retrieving Qlik Sense sheets.

This tool connects to a Qlik Sense server, opens the specified application, creates a SheetList session object, retrieves all sheet metadata, and returns the results as structured JSON.

ParametersJSON Schema

Name	Required	Description	Default
`args`	Yes	Retrieve all sheets from a Qlik Sense application. This tool connects to a Qlik Sense server, opens the specified application, creates a SheetList session object, retrieves all sheet metadata, and returns the results as structured JSON.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A3.9/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description bears full responsibility. It describes the steps (connects, opens app, creates SheetList, retrieves metadata) but does not disclose potential side effects, authentication requirements, or rate limits. Adequate but not exhaustive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a few sentences long, front-loaded with the purpose. It could be slightly more concise (e.g., 'Retrieve all sheets from a Qlik Sense app' instead of the longer first sentence). No waste, but some redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of an output schema (not shown but indicated), the description need not explain return values. It covers the process adequately. However, it lacks usage guidelines or caveats, making it slightly incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. The tool description adds minimal value beyond the schema's param descriptions, e.g., it repeats 'retrieves all sheet metadata'. No additional clarification on format or usage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves Qlik Sense sheets, with specific verb+resource. The sibling tools (e.g., handle_get_app_dimensions, handle_get_app_fields) indicate distinct resources, making this one unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains the tool connects to a server and retrieves sheets, but does not explicitly tell when to use this tool versus alternatives like handle_get_sheet_objects. However, the context of sibling tools and the name imply it is for listing all sheets.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

handle_get_app_variablesA

MCP tool handler for retrieving Qlik Sense variables.

This tool connects to a Qlik Sense server, opens the specified application, creates a VariableList session object, retrieves all variable metadata, and returns the results as structured JSON.

ParametersJSON Schema

Name	Required	Description	Default
`args`	Yes	Retrieve all variables from a Qlik Sense application. This tool connects to a Qlik Sense server, opens the specified application, creates a VariableList session object, retrieves all variable metadata, and returns the results as structured JSON.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A3.7/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses the tool is read-only (no destructive hints) and describes the server connection and session creation. However, it omits details like authentication requirements, rate limits, or potential side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences that efficiently convey the tool's purpose and process. The first sentence is somewhat technical ('MCP tool handler') but still clear. It is front-loaded and avoids unnecessary detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the low complexity (one required parameter, four optional booleans) and the presence of an output schema, the description adequately covers the behavior. It explains the retrieval mechanism and return format. It does not state pagination or limits, but the booleans handle filtering.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with clear parameter descriptions (e.g., app_id as 'GUID format or app name', booleans like 'Include variable definitions/expressions'). The tool description does not add extra meaning beyond the schema, so baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves Qlik Sense variables with specific steps ('connects to a Qlik Sense server, opens the specified application, creates a VariableList session object'). The purpose is distinct from sibling tools targeting other entities like fields, measures, sheets, etc.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for retrieving variables but provides no explicit guidance on when to prefer this tool over siblings. It does not mention alternatives or exclusion criteria, leaving the agent to infer from the name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

handle_get_sheet_objectsB

MCP tool handler for retrieving visualization objects from a sheet.

This tool connects to a Qlik Sense server, opens the specified application, retrieves the sheet and all its visualization objects with detailed metadata, and returns the results as structured JSON for analysis.

ParametersJSON Schema

Name	Required	Description	Default
`args`	Yes	Retrieve all visualization objects from a specific sheet. This tool connects to a Qlik Sense server, opens the specified application, retrieves the sheet and all its visualization objects with detailed metadata, including support for containers and nested objects.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

B3.4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It mentions connecting, opening an app, retrieving objects, and returning JSON, but omits details like authentication requirements, read-only nature, performance implications, or error handling. The description lacks sufficient behavioral context for safe invocation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise, consisting of two sentences. The first sentence is slightly redundant ('MCP tool handler for retrieving...'), but overall it is efficient with minimal waste. Could be tightened by removing redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, return value explanation is not required. However, the description does not cover nuances like container support or nested objects mentioned in the schema. It provides a high-level overview but lacks completeness regarding the complexity of the six parameters and their interactions.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with each parameter having a clear description in the input schema. The tool description does not add meaning beyond the schema, so it meets the baseline of 3. It neither significantly enhances nor detracts from parameter understanding.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description explicitly states the tool retrieves visualization objects from a sheet, with a clear verb ('retrieving') and resource ('visualization objects from a sheet'). It distinguishes itself from sibling tools, which handle app-level metadata (e.g., dimensions, measures) or list sheets, by focusing on objects within a specific sheet.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for analyzing sheet visualizations but does not explicitly state when to use this tool versus alternatives like handle_get_app_sheets for listing sheets or handle_get_app_measures for app-level metadata. No when-not-to-use guidance is provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

handle_list_qlik_applicationsA

MCP tool handler for listing all Qlik Sense applications.

This tool connects to Qlik Sense server global context and retrieves a list of all available applications with their names and IDs.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A3.6/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description only states it retrieves a list. It does not mention any side effects, authentication, performance, or additional behavioral traits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, clear and to the point. It could be slightly more concise but has no unnecessary content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a list tool with no parameters and an output schema, the description is adequate but lacks details like pagination, ordering, or note about potential large results. It is minimally complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There are no parameters, so the baseline is 4. The description correctly indicates no input is needed.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it lists all Qlik Sense applications with names and IDs, using a specific verb and resource. It distinguishes from sibling tools which target specific application details (e.g., fields, sheets).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use as an entry point to get an app overview before using sibling tools, but lacks explicit when-to-use or when-not-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

9 tool updatesv1.0.0Jun 17, 2026
- First observedhandle_get_app_data_sources
- First observedhandle_get_app_dimensions
- First observedhandle_get_app_fields
- First observedhandle_get_app_measures
- First observedhandle_get_app_script
- First observedhandle_get_app_sheets
- First observedhandle_get_app_variables
- First observedhandle_get_sheet_objects
- First observedhandle_list_qlik_applications

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.9/5.0

Disambiguation5/5

Each tool targets a distinct Qlik Sense application component (data sources, dimensions, fields, measures, script, sheets, variables, sheet objects, or app listing). There is no functional overlap; an agent can easily select the correct tool for a specific task.

Naming Consistency4/5

All tool names follow a consistent pattern: 'handle_verb_noun' (e.g., handle_get_app_fields). The prefix 'handle_' is a code artifact that is not user-friendly, but the verb-noun structure after it is consistent and predictable.

Tool Count5/5

With 9 tools, the set is well-scoped for a read-only analysis server. Each tool covers a major aspect of Qlik Sense applications, and there is no redundancy or unnecessary tools.

Completeness4/5

The tool set covers the primary read operations for Qlik Sense applications: listing apps, retrieving script, data model components (fields, data sources), and analytics objects (dimensions, measures, sheets, variables, sheet objects). Minor gaps exist, such as lacking support for bookmarks or master items, but core workflows are covered.

Maintenance

ActivityInactive

ResponsivenessResponsive

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Artificial Wit AIOAuth
com.artificialwit
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
ERP Systems CRM Knowledge & Memory
2
RevoGrid DataGrid MCP A
io.github.revolist
Token-free MCP server for structured RevoGrid Core, Pro, and Enterprise knowledge retrieval.
Documentation Access Developer Tools
823,392
mcpOAuth
com.jepto
Jepto MCP server that provides access to client knowledgebase & analytics for connected data sources
Knowledge & Memory Databases Search
2
Swagger MCPOAuth
com.smartbear
MCP server for AI access to Swagger by SmartBear.
API Testing Documentation Access Developer Tools
144

Related MCP Servers

superset-mcp
Databases Data Visualization Data Platforms
thedeceptio
F
license
B
quality
D
maintenance
An MCP server that provides AI assistants with full access to Apache Superset instances, enabling interaction with dashboards, charts, datasets, databases, and SQL execution capabilities.
Updated 5 months ago (2026-04-17 08:57 UTC)
34
-
Metabase MCP Plus
Databases Data Visualization Search
schachan
A
license
A
quality
C
maintenance
An MCP server that enables AI assistants to query databases, execute SQL, and manage Metabase resources like dashboards, cards, and collections through natural language.
Updated 6 months ago (2026-03-20 01:45 UTC)
22
MIT
mcp-sac-tools
pmankineni
A
license
A
quality
D
maintenance
MCP server for SAP Analytics Cloud, enabling AI assistants to interact with SAC stories, models, data, users, and audit logs via the SAC REST API.
Updated 4 months ago (2026-05-07 07:14 UTC)
34
ISC
@sedis/mcpofficial
Finance Real Estate Search
sedis-ab
A
license
A
quality
A
maintenance
An MCP server that provides read-only access to Sedis Bolagsanalys and Fastighetsbenchmark data via natural language, enabling AI assistants to query Swedish listed-company financials and real-estate comparables.
Updated 9 days ago (2026-08-28 06:34 UTC)
12
43
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/arthurfantaci/qlik-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

Qlik MCP Server

Features

Why This Matters

🛠️ Modern Development Stack

Prerequisites

Quick Start

1. Installation

2. Configuration

3. Certificate Setup

4. Test Connection

5. Configure with Cursor IDE

6. Configure with VS Code

7. Configure with Claude Desktop

Usage

Running as MCP Server

Available Tools

Enhanced Script Tool Examples

Basic Script Retrieval

Script with Full Analysis and BINARY LOAD Detection

Script with Section Parsing

Script Preview with Line Numbers

Complete Analysis with All Features

Using with Different MCP Clients

Cursor IDE

VS Code

Claude Desktop

Tool Parameters

get_app_measures Tool

list_qlik_applications Tool

get_app_variables Tool

get_app_fields Tool

get_app_sheets Tool

get_sheet_objects Tool

get_app_dimensions Tool

get_app_script Tool

get_app_data_sources Tool

Response Formats

get_app_measures Response

list_qlik_applications Response

get_app_variables Response

get_app_fields Response

get_app_sheets Response

get_sheet_objects Response

get_app_dimensions Response

get_app_script Response

get_app_data_sources Response

Project Structure

Security

Troubleshooting

Connection Issues

MCP Issues

Development

Running Tests

Setup Test Environment

Pytest Testing Commands

Test Categories

Test Specific Functionality

Code Quality & Formatting

Continuous Integration (CI/CD)

Adding New Tools

Tool Definitions

Limitations

Future Enhancements

Recent Enhancements

Script Tool v2.0 (Latest)

License

Support

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Tool Schema Changelog

Maintenance

Resources

`get_app_measures` Tool

`list_qlik_applications` Tool

`get_app_variables` Tool

`get_app_fields` Tool

`get_app_sheets` Tool

`get_sheet_objects` Tool

`get_app_dimensions` Tool

`get_app_script` Tool

`get_app_data_sources` Tool

`get_app_measures` Response

`list_qlik_applications` Response

`get_app_variables` Response

`get_app_fields` Response

`get_app_sheets` Response

`get_sheet_objects` Response

`get_app_dimensions` Response

`get_app_script` Response

`get_app_data_sources` Response