Skip to main content
Glama
Intel NPU Tools MCP Server
by etreby

Intel NPU Tools for Linux

An unofficial, community-maintained toolkit that makes the integrated Intel AI Boost NPU in Arrow Lake processors useful on Linux. It provides private semantic search, local speech transcription, screenshot OCR, hardware verification, and twelve MCP tools that AI agents can call.

Validate Release License: MIT

This project is not affiliated with, sponsored by, or endorsed by Intel Corporation. Intel, Intel Core, OpenVINO, and Intel AI Boost are trademarks of their respective owners.

Why this exists

Linux can expose an Arrow Lake NPU as /dev/accel/accel0, but applications still need Intel's Level Zero NPU user-mode driver, OpenVINO, compatible models, permissions, and integration code. This repository assembles those pieces into useful desktop and agent workflows.

The NPU is a good fit for efficient background inference. It does not replace a discrete GPU for model training, large language models, or image generation.

Related MCP server: macOS Companion MCP Server

Features

  • Speech to text: multilingual Whisper Base INT8 runs locally on the NPU. Whisper Small is available for noisier rooms; see the roadmap for the accuracy and latency trade. Whole recordings get timestamped output: intel-npu-transcribe turns a meeting recording into VTT, SRT and Markdown in seconds.

  • Screenshot OCR: select a region and copy recognized English or Arabic text.

  • Private semantic search: index local documents, logs, and source code with Qwen3-Embedding 0.6B INT8, then retrieve passages by meaning.

  • Smaller agent context: context_filter returns only the lines of a large log or file that answer a question, verbatim and with line numbers, and screen_to_text renders a screen as a few hundred tokens of structured text rather than a multi-thousand-token image.

  • MCP server: Codex, Claude, Gemini CLI, AGY/Antigravity CLI, Hermes, Antigravity IDE, OpenCode, and other MCP clients can use all twelve tools.

  • Hardware diagnostics: report every OpenVINO device and confirm Intel(R) AI Boost is available.

  • Reversible installation: user applications and models are isolated under ~/.local; the uninstaller deliberately preserves system drivers.

Supported hardware and software

The initial tested target is:

  • Intel Arrow Lake integrated NPU 3720, PCI ID 8086:ad1d

  • Intel Core Ultra 200-series desktop processors, including Core Ultra 9 285K

  • Ubuntu 24.04 or an Ubuntu 24.04-compatible distribution

  • Linux kernel 6.8 or newer with intel_vpu

  • KDE Plasma, GNOME, COSMIC, or a wlroots compositor; X11 works too. Screenshots use whichever of spectacle, gnome-screenshot, cosmic-screenshot, grim, maim or scrot is installed, and the clipboard uses wl-clipboard, xclip or xsel.

OpenVINO officially identifies Arrow Lake's NPU 3720 by PCI ID 0xAD1D. Other Intel NPU generations may work with code changes, but the bundled driver safety check intentionally refuses unknown PCI IDs.

What it looks like

The control panel is where every feature can be tried and every setting changed.

Voice tab: record from the microphone or transcribe a file, on the NPU

Search indexes a folder and retrieves passages by meaning, and context_filter returns only the lines of one large file that answer a question.

Search tab: semantic search across an indexed folder

Settings that used to be environment variables are editable and persistent. Each option states what it measured, so the trade is visible before it is made.

Config tab: speech model, compiled-model caching, and turbo

The status tab reports the device, the driver, which models are installed, and what the desktop session can actually do — useful when a screenshot or the clipboard is not working.

Status tab: OpenVINO devices, NPU driver and compiler, installed models, desktop capabilities

Regenerate these with scripts/capture-screenshots.sh. It runs each window on a virtual display, so the images do not depend on anyone's wallpaper or theme and stay reproducible as the interface changes.

Install from a package

Native packages install the toolkit system-wide. They deliberately contain no models and no OpenVINO runtime: those are large, are redistributed under their own licences, and OpenVINO is not in any distribution archive. Each user runs intel-npu-tools-setup once afterwards to build their own environment and download the models, which also keeps package installation off the network.

./scripts/build-deb.sh                                  # Debian, Ubuntu, Pop!_OS
cd packaging && makepkg -si                             # Arch
rpmbuild -bb packaging/intel-npu-tools.spec \
         --define "_projectdir $PWD"                    # Fedora (openSUSE and EL untested)

All three install the same tree from scripts/stage-package.sh, so they cannot drift apart. Then, as your own user:

intel-npu-tools-setup            # add --with-reranker and --with-whisper-small if wanted

Quick installation

git clone https://github.com/etreby/intel-npu-tools.git
cd intel-npu-tools
./install.sh --with-driver

--with-driver installs Intel's signed Ubuntu 24.04 NPU user-mode packages and firmware, adds the current user to render, creates an isolated Python environment, downloads the models from their official upstream locations, and installs the desktop and MCP tools.

Log out and back in after the first driver installation, then verify:

intel-npu-info

Expected output includes:

"NPU": "Intel(R) AI Boost"

If the driver is already installed, omit --with-driver:

./install.sh

To skip automatic MCP client registration:

./install.sh --without-mcp

The model download is approximately 800 MB in total, including Whisper, OCR, and the roughly 600 MB embedding model. Two optional models are excluded by default: --with-whisper-small (~250 MB, better in noise) and --with-reranker (~300 MB, sharper search results).

Semantic search in 30 seconds

intel-npu-search index ~/Projects/my-project
intel-npu-search search "Where is authentication configured?"
intel-npu-search status

Indexing is incremental and remains local. See the semantic-search guide for supported files, performance, privacy boundaries, and customization.

Desktop usage

Launch these applications from the desktop menu:

  • Intel NPU Speech to Text: click Start, speak, then Stop and transcribe. The result is copied to the clipboard.

  • Intel NPU Screenshot OCR: select a rectangular region. Recognized text is displayed and copied.

  • Intel NPU Control Panel: try every feature, change settings, and see what the NPU and the desktop session can actually do. Run intel-npu-panel.

On KDE, install.sh registers two global shortcuts:

  • Meta+F9 — Speech to Text

  • Meta+Alt+O — Screenshot OCR

Meta is normally the Windows-logo key. The shortcuts start working after your next login, because KDE's shortcut daemon reads its configuration once at session start; restarting it during an install would briefly drop every other shortcut on the system. If you had already bound either application to a key of your own, the installer leaves your binding alone, and it refuses to write a key another component already owns rather than registering one KDE would silently discard. Speech uses Meta+F9 rather than the Meta+Alt+S of earlier versions, because KDE's accessibility component binds Meta+Alt+S to "Toggle Screen Reader On and Off" by default, so that shortcut could never have worked. On a desktop without KDE's configuration tools the registration is skipped and the applications are launched from the desktop menu instead.

Transcribing recordings

Dictation in the Speech to Text app answers what was said. intel-npu-transcribe answers the question a meeting or lecture recording raises afterwards: what was said, and when. It reads a file, streams the audio through the NPU in Whisper-sized windows cut at the nearest pause, and returns timestamped segments, writing WebVTT, SubRip and Markdown renderings next to it:

intel-npu-transcribe meeting.wav
# writes meeting.vtt, meeting.srt and meeting.md in the same directory
intel-npu-transcribe podcast.opus -o ~/Documents/transcripts --formats srt,md

Each Markdown paragraph carries the time it begins, and the header records the detected language and duration, so the transcript reads like notes rather than a teleprompter script. Timestamps come from the model itself (return_timestamps), shifted onto the file's timeline by the chunker, and chunks with no speech in them are skipped rather than transcribed, which is what keeps an empty conference room from becoming invented dialogue. The file formats are whatever ffmpeg reads: WAV, MP3, M4A, FLAC, OGG, OPUS and WEBM all work.

Measured on Arrow Lake with Whisper Base: a 10.1 minute WAV transcribed in 12.3 seconds of wall time — about thirty times faster than real time — at 3.3 percent word error rate against a reference script read by a natural-voice synthesizer, with the machine's discrete GPUs untouched throughout. Whisper Small can be selected for noisier rooms the same way as for dictation: INTEL_NPU_TOOLS_WHISPER_MODEL=whisper-small-int8-ov.

MCP agents get the same outputs from the transcribe_audio tool by passing formats="vtt,srt,md"; the reply then contains the language, duration, every timestamped segment, and the rendered documents.

AI agent and MCP usage

The local stdio MCP command is:

intel-npu-mcp

It exposes:

Tool

Purpose

npu_status

Verify OpenVINO and list available devices

transcribe_audio

Transcribe a local audio file on the NPU

record_and_transcribe

Record the default microphone for a bounded duration

ocr_image

Extract English/Arabic text from an image

ocr_current_monitor

Capture and OCR the current monitor

screen_to_text

Read a screen as structured text instead of an image

semantic_index

Incrementally index a text file or directory on the NPU

semantic_search

Retrieve ranked local passages by meaning

context_filter

Return only the parts of a large file that answer a question

semantic_index_status

Show indexed roots, files, chunks, and database path

open_speech_app

Open the interactive speech application

open_ocr_selector

Open interactive region OCR

Example agent requests:

Use intel-npu-tools to transcribe ~/recording.m4a.
Use the NPU to OCR ~/Pictures/error.png.
Record my microphone for 15 seconds and transcribe it.
Read the text currently visible on my monitor.
Index ~/Projects/my-project, then find where authentication is configured.
Search my indexed documents for the Windows boot recovery procedure.

Manual Codex registration:

codex mcp add intel-npu-tools -- "$HOME/.local/bin/intel-npu-mcp"

Manual Claude Code registration:

claude mcp add --scope user intel-npu-tools -- "$HOME/.local/bin/intel-npu-mcp"

Manual Hermes registration:

hermes mcp add intel-npu-tools --command "$HOME/.local/bin/intel-npu-mcp"

Manual Gemini CLI registration:

gemini mcp add --scope user intel-npu-tools "$HOME/.local/bin/intel-npu-mcp"

AGY/Antigravity CLI reads global servers from ~/.gemini/config/mcp_config.json:

{
  "mcpServers": {
    "intel-npu-tools": {
      "command": "/home/YOUR_USER/.local/bin/intel-npu-mcp",
      "args": []
    }
  }
}

OpenCode reads global configuration from ~/.config/opencode/opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "intel-npu-tools": {
      "type": "local",
      "command": ["/home/YOUR_USER/.local/bin/intel-npu-mcp"],
      "enabled": true,
      "timeout": 60000
    }
  }
}

Any MCP client can use this stdio configuration:

{
  "mcpServers": {
    "intel-npu-tools": {
      "command": "/home/YOUR_USER/.local/bin/intel-npu-mcp",
      "args": []
    }
  }
}

How the NPU is utilized

Microphone/audio ──> Whisper Base INT8 ──> OpenVINO GenAI ──> Intel NPU
Long audio file ──> pause-aligned chunks ──> the same Whisper pipeline ──> VTT/SRT/Markdown
Screenshot/image ──┬─> text detector + recognizer ──> OpenVINO ──> Intel NPU
                   └─> Tesseract (preferred for layout, punctuation, Arabic)
Local text ──> chunks ──> Qwen3 Embedding INT8 ──> Intel NPU ──> SQLite vectors
AI agent ──> local stdio MCP server ──> the same NPU pipelines

All inference targets NPU explicitly. The included tools do not silently redirect workloads to a discrete GPU. This allows an NVIDIA or Intel GPU to remain available for gaming, rendering, Ollama, or larger AI workloads.

Privacy

  • No network server is started.

  • MCP communication uses a local child process over stdin/stdout.

  • Audio, screenshots, indexed text, and embeddings are processed and stored locally.

  • Network access is needed only during installation to download software and models.

  • Temporary recordings and screenshots are deleted after processing.

Documentation

Troubleshooting

/dev/accel/accel0 is missing

lspci -nn | grep -i ad1d
lsmod | grep intel_vpu
journalctl -k -b | grep -i intel_vpu

Update the kernel/firmware for your distribution before replacing unrelated graphics drivers.

NPU exists but OpenVINO shows only CPU/GPU

groups
ls -l /dev/accel/accel0

The user must belong to render. Log out and back in after group changes.

Speech produces no text

Check the default PipeWire microphone:

pactl get-default-source
pw-record --rate 16000 --channels 1 /tmp/microphone-test.wav

OCR limitations

Both engines run on every image. The NPU detects text regions and recognizes them with Intel's compact model, which covers only lowercase Latin letters and digits. Tesseract reads punctuation, layout, English, and Arabic, so its output is used as the returned text whenever it produces any; the NPU result is returned when Tesseract is missing, fails, or finds nothing. npu_regions and npu_text are always reported separately so you can see what the NPU contributed. Stylized fonts and very small text may remain imperfect.

install.sh installs Tesseract. Without it, OCR still works but falls back to the NPU-only text.

For NPU compilation, semantic-search, and MCP diagnostics, use the complete debugging guide.

Development

python3 -m venv .venv
source .venv/bin/activate
pip install -e .
python -m compileall -q src

See CONTRIBUTING.md for contribution guidelines and proposed areas of work.

Uninstall

./uninstall.sh

The uninstaller removes user applications, models, and MCP registrations. It intentionally preserves system-level NPU firmware and drivers.

Upstream components and documentation

License

Project code is released under the MIT License. Downloaded drivers, models, runtimes, and trademarks remain under their respective upstream licenses. See THIRD_PARTY_NOTICES.md.

Available Tools

12 tools
context_filterA

Extract only the parts of a large local text file that are relevant to a question.

Use this instead of reading a big build log, test output, diff, or data file into your context. Write the output to a file first, then filter it:

make 2>&1 | tee /tmp/build.log
context_filter("/tmp/build.log", "why did the linker step fail")

Returns spans copied verbatim from the file with exact line numbers, never a summary, so quoted text and line numbers can be cited. It also reports how much was dropped and how close the best dropped chunk scored, so you can tell when to widen the query or raise limit rather than assuming full coverage.

Chunks are embedded on the Intel NPU and ranked by cosine similarity; nothing is written to the semantic index and nothing leaves this machine. This is not a substitute for grep: when you know the exact string to look for, grep is faster, free, and exact. Files under 4 KB and over 256 KB are rejected.

Inputs: path (required), query (required), limit, context_lines.

npu_statusA

Report OpenVINO devices and whether Intel AI Boost is available.

Inputs: no named parameters.

ocr_current_monitorA

Capture the current monitor and extract its text.

Inputs: no named parameters.

ocr_imageB

Extract English and Arabic text from a local image using NPU text models.

Inputs: image_path (required).

open_ocr_selectorB

Open the rectangular screenshot OCR selector.

Inputs: no named parameters. Returns: result

open_speech_appA

Open the interactive speech-to-text desktop application.

Inputs: no named parameters. Returns: result

record_and_transcribeA

Record the default microphone for 1-60 seconds and transcribe on the NPU.

Inputs: seconds. Returns: result

screen_to_textA

Read a screenshot as compact structured text instead of sending an image.

A screenshot costs a vision model roughly 1,600 to 4,800 image tokens. This returns the same screen as a few hundred tokens of text in reading order, with a bounding box per line, so you can see what is on screen and where to click without spending them. Omit image_path to capture the current monitor.

detail is "lines" (default: text plus one box per line), "text" (cheapest, reading order only), or "words" (a box per word — on a dense screen this can cost MORE tokens than the screenshot did, and the reply says so when it has).

Read these limits before relying on it. The text comes from Tesseract OCR, so it is a best-effort transcription and not a user-interface tree: it cannot report widget types, enabled or checked state, focus, scroll position, or anything off-screen, and it misreads small or low-contrast text. If the target is a web page, use Playwright's accessibility tree instead — that is already structured text, it is exact, it includes content scrolled out of view, and it costs no model tokens to produce. This tool is for surfaces with no such tree: native desktop applications, remote desktops, canvas and WebGL, video frames, and scanned documents.

Inputs: detail, image_path, min_confidence.

semantic_indexA

Index a local text file or directory for private semantic search on the Intel NPU.

Inputs: path (required).

semantic_index_statusA

Report the local semantic index database, roots, file count, and chunk count.

Inputs: no named parameters.

transcribe_audioA

Transcribe a local audio file on the Intel NPU.

Inputs: audio_path (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.6/5.0

    Scored across 12 tools

    Disambiguation3/5

    Several tools overlap: ocr_image, ocr_current_monitor, and screen_to_text all perform OCR, with screen_to_text also able to capture the current monitor like ocr_current_monitor. However, the descriptions clarify their distinct intents: screen_to_text returns structured, coordinate-aware text for UI automation, while ocr_* are straightforward text extraction. The audio and semantic search tools are more clearly separated, though context_filter and semantic_search both use embeddings in different ways.

    Naming Consistency2/5

    Tool names mix verb-first and noun-first patterns inconsistently: verbs appear in ocr_image, transcribe_audio, record_and_transcribe, open_speech_app, and open_ocr_selector, while nouns lead semantic_index, semantic_search, context_filter, npu_status, and semantic_index_status. Status tools are not uniformly named (npu_status vs semantic_index_status), and screen_to_text uses a prepositional phrase instead of a verb_noun form. This creates a haphazard feel that hinders predictability.

    Tool Count4/5

    Twelve tools is within the typical well-scoped range, but the inclusion of four OCR-related tools (ocr_image, ocr_current_monitor, screen_to_text, open_ocr_selector) feels redundant; one or two could be merged without losing capability. The count is not excessive, though minor trimming would improve focus.

    Completeness4/5

    The NPU domain is broad, but this server effectively covers the highlighted use cases: OCR, audio transcription, and semantic search. Gaps include no way to delete or remove files from the semantic index, no model management or listing beyond basic status, and limited OCR language support (English/Arabic only). These are workable for most tasks, so the surface is nearly complete rather than severely lacking.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers