Qlik Sense MCP Server
The Qlik Sense MCP Server provides a unified interface for interacting with Qlik Sense Enterprise APIs, enabling comprehensive application management, data analysis, and administrative operations.
Core Capabilities:
Application Management: Retrieve application lists with filtering and pagination (
get_apps), detailed metadata including object counts (get_app_details,get_app_metadata), and load scripts (engine_get_script)Data Analysis & Extraction: Extract field values with frequency (
engine_get_field_values), generate statistical analysis including min/max/median/standard deviation (engine_get_field_statistics), create hypercubes for advanced analysis (engine_create_hypercube), and export data in JSON/CSV formats (engine_create_data_export)Administrative Management: Access users (
get_users), streams (get_streams), data connections (get_data_connections), tasks (get_tasks), extensions (get_extensions), and content libraries (get_content_libraries)Task Automation: Execute specific tasks by ID (
start_task) for automated workflowsEngine API Integration: Direct interaction with Qlik Sense Engine API for document listing (
engine_get_doc_list), application operations, sheet retrieval (engine_get_sheets), and table data extraction (engine_get_table_data)Security & Performance: Certificate-based authentication for secure access, optimized queries, and pagination for efficient data retrieval
Uses .ENV files for configuration management of Qlik Sense connection details, authentication credentials, and API settings.
Integrates with GitHub Actions for automated build and publication processes to PyPI when new version tags are pushed.
Supports installation from PyPI and automated publication of new versions through GitHub Actions workflows.
Provides unified interface for Qlik Sense Enterprise Repository API and Engine API operations, enabling access to applications, users, data models, analytics, and data export functionality through 21 specialized tools.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Qlik Sense MCP Server list all applications with their 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 Sense MCP Server
Model Context Protocol server for
Qlik Sense Enterprise. Exposes Qlik's Repository (HTTP) and Engine
(WebSocket) APIs as 28 MCP tools so an LLM client can discover apps,
inspect data models, query data, and manage reload tasks through a
single uniform interface. In JWT and form (login/password) mode the 14
reload-task tools are hidden by default: QRS task administration needs an
admin role in the QMC, which a JWT analyst or a form login usually does
not hold. That is a property of the identity, not of how it authenticated,
so QLIK_TASK_TOOLS=true turns them on for an identity that does hold it.
What's in the box
Area | Tools | Used for |
Repository (apps & metadata) |
| Discover apps, list tables and fields with cardinalities |
Engine (data & script) |
| Query data, read load script, list visualizations, inspect field values |
Reload tasks (certificate mode by default; opt-in elsewhere, see below) |
| Inspect, trigger and manage reload tasks |
Full list with descriptions: docs/tools.md.
The main analysis call takes the question, not the Qlik syntax for it:
// engine_query — "revenue by region for 2024, biggest first"
{
"app_id": "<app guid>",
"group_by": ["region_name"],
"metrics": [{"field": "amount", "agg": "sum", "label": "Revenue"}],
"filters": [{"field": "order_date", "period": "2024"}],
"sort_by": "Revenue",
"limit": 10
}The server writes the set analysis, checks that the filter selects
something, and answers with period_check — the earliest and latest
date actually in the result — so a filter that failed to apply is
visible instead of hiding behind a plausible number. Independent
questions go in one call as queries and share three round-trips.
Harder questions stay in the same form. A share of the whole, with the numerator narrowed and the denominator not:
{
"group_by": ["region_name"],
"metrics": [{"label": "Share", "op": "divide", "of": [
{"field": "amount", "agg": "sum",
"filters": [{"field": "category", "values": ["Alpha"]}]},
{"field": "amount", "agg": "sum", "total": true}]}]
}The same form states an aggregation over an aggregation
("inner_agg": "sum", "per": "order_id", "agg": "median"), the clients
who bought in one year and not the next (matching / not_matching),
counting over a bookmark or ignoring selections (scope), and values
kept, dropped, added or intersected on any field.
The app's own master measures are named rather than rebuilt -
"measures": [{"master": "Revenue"}] - and take the query's filters as
an outer set in front of them.
engine_create_hypercube takes the same shape with the expressions
written by hand, for calculations the typed form cannot state.
Related MCP server: Looker Admin MCP
Quick start
uvx qlik-sense-mcp-serverThe server starts in Streamable HTTP
mode on http://127.0.0.1:8000/mcp. Configure it via environment
variables — see docs/configuration.md.
For stdio mode (legacy MCP transport), pass --stdio.
Three authentication modes are supported: client certificate (legacy,
full QRS access), JWT via virtual proxy (per-analyst, no on-disk
secrets), and login/password against a "Form based" virtual proxy
(e.g. the in-box Windows credentials login page). See
docs/AUTH_JWT.md and
docs/AUTH_FORM.md for setup.
Documentation
Document | What's inside |
Requirements, install via | |
All | |
JWT authentication via virtual proxy: key generation, virtual proxy setup, | |
Login/password authentication via a "Form based" virtual proxy: how the login flow works, | |
Transports, server start commands, recommended call order, hard limits enforced by this server | |
Inventory of all 28 tools, response/error envelope, error categories | |
Project layout, components, connection caching, strict id-matching, two-tier timeout | |
| |
Common errors, hypercube planning failures, verbose logging, configuration self-test | |
What models actually do with this server, measured: calls per question, where they go wrong, session limits, how to benchmark honestly | |
Release notes |
Key facts
A wrong query is refused, not answered. Qlik evaluates an unknown field name as an expression worth 0, so a hypercube grouped by a typo came back as a single row holding the grand total — a plausible number with nothing to mark it as wrong. Every query is checked by Engine before it runs:
ExpandExpressionresolves variables,CheckExpressionreports syntax and unknown names,GetFieldsFromExpressionreports the fields a set modifier actually filters on. The four checks cost about 4ms in one batch, against 75ms for the smallest hypercube.A period filter is measured, not assumed. Comparison inside a set modifier runs against the text Qlik displays for a value, so a serial number range returns 0 on a field displayed as
01.01.2024and works on one displayed as45292— with no error either way. State the period as a filter and the server writes it as a range in the field's own display format, checks it against a reference count, falls back to the numeric range and then to the form that always works, and reports the period the result actually covers - and when a shifted calendar made the period reach facts outside it.Filters reach the author's measures.
{"master": "Revenue"}with a period is computed as{&<period>} [Revenue], an outer set in front of the measure, and the reply names a measure that sets a filtered field itself or counts over a set of its own, where the filter does not reach.One value, one writing. A date in a query result reads as the text Qlik displays for it, the same as the sample values in
get_app_detailsand the bounds fromengine_get_field_range.A field name is always written in brackets. A bare
Тип ставкиis read by Qlik's parser as two tokens — "Garbage after expression: 'ставки'" — which used to refuse queries Qlik itself runs happily.Aggregating over groups, not rows.
perandinner_aggstate "sum per issue, then the 85th percentile across issues", which is a different question from a percentile over rows and gives a different number.A measure can narrow itself. Its own
filtersoverride the query's, so a KPI carries its numerator and its denominator in one answer.Objects say what they show.
get_app_sheet_objectsgives each object one line - its dimensions, its measures with their expressions, the conditions and variables it depends on, what a filter or button does - andfields_used, including fields reached through master items and the ones inside a filter pane's listboxes — so "what does this sheet work with" is one call, with nothing calculated.Paging is done by Qlik, not after it. App and task listings read
/{entity}/tablewithskip/takeand take the total from/{entity}/count, so nothing past the QRS record limit goes missing andtotal_foundis the real total. Field search and field paging likewise happen in Engine — verified on a field with 200,000 distinct values, where the old local scan simply could not see a match.A failure is never an empty answer. A QRS 500, a refused connection or an Engine error used to arrive as
[],""or "no schedule", which reads as a tidy, empty Qlik. Every such path now returns anerror_categoryand the original cause.Column meanings, not just column names. Fields and tables commented in the load script (
COMMENT FIELD/COMMENT TABLE) carry that text intoget_app_detailsascomment, and intoget_app_fieldasfield_comment, so the model reads what a column means instead of guessing from its name. Added in 1.7.2.Runs on both MCP SDK lines. SDK 2.0 dropped
FastMCP; the server now picksMCPServer(2.x) orFastMCP(1.x) at import time, somcp>=1.8.0,<3.0.0all work. Both lines are covered by the test suite and were verified end to end against a live Qlik app.Ranked queries (top-N) in one call.
engine_create_hypercubetakessort_by(a measure label, a measure expression or a dimension field),sort_order(desc/asc) andlimit, so "the 10 clients with the highest GGR" is a single request. Before v1.6.0 sorting by a measure silently did nothing —qInterColumnSortOrderwas hard-coded to the dimensions, so the server returned the alphabetically first rows instead of the largest ones.NULL groups are visible, not hidden. Facts with no value for the grouping field collapse into Qlik's
"-"row, which often holds a large total and can take first place in a top-N. It is kept by default — a fact with no grouping value is still a fact — andexclude_null_dimensions=trueleaves it out.Compact, LLM-friendly results. The hypercube response is
columns+rowswith real numbers, plusgrand_totaland per-steptimings. Passinclude_raw_layout=truefor the full Qlik layout.Failures name the query that failed. Every error reply, timeouts included, echoes
toolandrequestwith the exact arguments sent.Fewer useless tools in JWT/form mode, by default. Reload-task administration needs QRS admin rights — a QMC role, not a property of the authentication method — so those 14 tools default to on in certificate mode and off in JWT/form mode: 28 tools with a certificate, 14 with a JWT or a login/password.
QLIK_TASK_TOOLS=trueturns them on in JWT/form mode too, for an identity verified to hold those rights.One Qlik session per server. Qlik's per-user limit (5 by default) counts proxy sessions, and in JWT/form mode one is created by the session bootstrap itself — before any WebSocket. The server therefore bootstraps once and reuses that session for every call; restarting it in a loop is what exhausts the quota, not the number of queries.
JWT authentication via virtual proxy. Set
QLIK_JWT_TOKENinstead of certificate paths and the server will authenticate every Repository and Engine call as the analyst encoded in the token. No certificates or private keys live on the host. The legacy certificate mode is unchanged and still required for full QRS access. Setup guide:docs/AUTH_JWT.md.Login/password authentication via a "Form based" virtual proxy. Set
QLIK_PASSWORD(plusQLIK_USER_IDand optionallyQLIK_USER_DIRECTORY) instead of a certificate or a JWT and the server logs into the proxy's login page the way a browser would, then reuses the resulting session cookie exactly like JWT mode does after its own bootstrap. Setup guide:docs/AUTH_FORM.md.Cached Engine WebSocket connections. Once an app is opened, every subsequent tool call against the same
app_idreuses the same WebSocket and the same open document. Switchingapp_idcloses the old document and opens the new one on the same socket. Dropped connections are reopened transparently. Implementation:engine/connection.pyanddocs/architecture.md.Streamable HTTP transport by default. The server is a long-lived process; multiple MCP clients can talk to it in parallel. The legacy stdio mode still works behind
--stdio.tool_call_secondsis injected as the first key of every tool response — wall-clock time of the call in milliseconds. Use it to spot slow tools.Hard hypercube limits.
engine_create_hypercuberejects requests withmax_rows > 5000orcolumns * max_rows > 9900immediately, with a structured error and a hint pointing at set-analysis or top-N patterns. Qlik Engine itself returns error 7009calc-pages-too-largefor any single page over 10000 cells.Two timeout knobs.
QLIK_WS_TIMEOUT(default180.0seconds) controls both the WebSocket handshake and every Engine API call;QLIK_TOOL_TIMEOUT(default240.0) bounds a whole tool call, so a slow one ends with a clear error before the client gives up on it.
Requirements
Python 3.12 (the package is built and tested against this version; see
pyproject.toml)Qlik Sense Enterprise (Repository on port 4242, Engine on port 4747 — the standard ports)
Client certificate, private key and root CA from the Qlik Sense node (certificate mode only - JWT and form mode need nothing on disk beyond the token or the password)
Network access from the host running this server to Qlik
Disclaimer
This project is an independent, community-built integration. It is NOT affiliated with, endorsed by, sponsored by, or supported by Qlik Technologies Inc., QlikTech International AB, or any other Qlik entity. "Qlik", "Qlik Sense", "QlikView" and all related product names are trademarks of their respective owners.
All information about Qlik Sense APIs, port allocations, error codes, protocol behavior and usage patterns used in this project was obtained exclusively from publicly available sources — the Qlik Developer Portal (help.qlik.com, qlik.dev), the Qlik Community forums, and other public documentation. No proprietary, confidential or reverse-engineered material is used.
License
MIT © 2025-2026 Stanislav Chernov
Available Tools
10 toolsengine_create_hypercubeA
Create hypercube for data analysis with custom sorting options. IMPORTANT: To get top-N records, use qSortByExpression: 1 in dimension sorting with qExpression containing the measure formula (e.g., 'Count(field)' for ascending, '-Count(field)' for descending). Measure sorting is ignored by Qlik Engine.
Inputs: app_id (required), dimensions, measures, max_rows.
get_app_detailsB
Get compact application info with filters by guid or name (case-insensitive). Returns metainfo, tables/fields list, master items, sheets and objects with used fields.
Inputs: app_id, name.
get_app_fieldC
Return values of a single field from app with pagination and wildcard search (supports * and %).
Inputs: app_id (required), field_name (required), limit, offset, +3 more.
get_app_field_statisticsC
Get comprehensive statistics for a field
Inputs: app_id (required), field_name (required).
get_app_objectC
Get specific object layout by calling GetObject and GetLayout sequentially via WebSocket.
Inputs: app_id (required), object_id (required).
get_appsA
Get list of Qlik Sense applications with essential fields and filters (name, stream, published) and pagination.
Inputs: limit, offset, name, stream, +1 more.
get_app_scriptC
Get load script from app
Inputs: app_id (required).
get_app_sheet_objectsC
Get list of objects from specific sheet with object ID, type and description.
Inputs: app_id (required), sheet_id (required).
get_app_sheetsC
Get list of sheets from application with title and description.
Inputs: app_id (required).
get_app_variablesB
Return variables split by source (script/ui) with pagination and wildcard search.
Inputs: app_id (required), limit, offset, created_in_script, +3 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 10 tools
Every tool has a clearly distinct purpose targeting specific Qlik Sense resources like apps, fields, objects, sheets, variables, or hypercubes, with no overlap in functionality. The descriptions reinforce this by detailing unique operations such as retrieving field statistics versus field values, ensuring agents can easily differentiate between tools.
All tool names follow a consistent verb_noun pattern with 'get_' or 'engine_' prefixes, using snake_case uniformly (e.g., get_app_details, get_app_field, engine_create_hypercube). This predictability makes the tool set easy to navigate and understand at a glance.
With 10 tools, the server is well-scoped for interacting with Qlik Sense applications, covering essential operations like listing apps, retrieving details, fields, objects, sheets, variables, scripts, and creating hypercubes. Each tool serves a distinct role without redundancy, fitting the domain appropriately.
The tool set provides comprehensive read and analysis capabilities for Qlik Sense apps, including data retrieval, statistics, and hypercube creation, but lacks write operations (e.g., updating or deleting apps, fields, or objects). This minor gap may limit agents in full lifecycle management but supports core query and analysis workflows effectively.
Maintenance
Related MCP Connectors
Governed data discovery, exact queries, decisions, simulations, and runtime utilities over MCP.
Read and edit GA4, Search Console and Google Tag Manager from any MCP client. 29 tools.
Governed BI MCP. Ask questions of live company data and list workspace sources via OAuth.
Securely query and analyze business data, dashboards, projections, alerts, and knowledge.
Related MCP Servers
- AlicenseBqualityCmaintenanceConnects AI assistants like Claude to Qlik Cloud and Qlik Sense Enterprise environments, enabling natural language interactions for analytics, app management, reloads, user administration, and data governance across 34 tools.3416MIT
- FlicenseNot gradedqualityDmaintenanceProvides over 60 administrative tools for managing users, groups, roles, schedules, alerts, and content access within Looker through the Model Context Protocol. It enables full administration of Looker environments, including permission management and system configuration.1-
- AlicenseAqualityDmaintenanceA comprehensive MCP server that provides complete access to Qlik Sense applications and their detailed information for AI assistants and other MCP clients.918MIT
- FlicenseNot gradedqualityDmaintenanceEnables AI applications to interact with Power BI through the Model Context Protocol, supporting comprehensive API operations including data retrieval and management.-