QodeAssist — AI coding assistant for Qt Creator

⚠️ Status: archived

I am shutting down the QodeAssist project completely and archiving it, because my copyright notices were removed without my knowledge or permission. All relevant evidence has been preserved.

After investing years of work into QodeAssist, I no longer feel able to continue developing a project when its code has already been used elsewhere without preserving proper attribution to its original author.

QodeAssist brings a full AI coding workflow to Qt Creator for C++ and QML — smart code completion, multi-panel chat, inline quick refactoring, and project-aware tool calling. It works with local runtimes (Ollama, llama.cpp, LM Studio) and cloud providers (Claude, OpenAI, Google AI, Mistral, Qwen, DeepSeek), can run as an MCP server so other clients reuse its project context, and can also act as an MCP client to consume tools from external MCP servers.

Table of Contents

1. Overview
2. Install Plugin
3. Configuration
4. Features
5. Context Layers
6. QtCreator Version Compatibility
7. Hotkeys
8. Troubleshooting
9. Development Progress
10. Support the Development
11. How to Build

Overview

QodeAssist enhances Qt Creator with AI-powered coding assistance:

• Code Completion — intelligent, context-aware suggestions (FIM and chat models) for C++ and QML, with multiline support
• Chat Assistant — side panel, bottom panel, or detached window; history with auto-save, token monitoring, extended thinking
• Quick Refactoring — inline AI-assisted edits directly in the editor with a searchable custom-instructions library
• Agent Tools — read, search, create and edit files; build the project; run terminal commands; access linter/compiler issues; manage TODOs
• Agent Skills — reusable folders of specialized instructions loaded on demand; discovered from .qodeassist/skills/ and .claude/skills/, invoked automatically, with /skill, or always-on
• MCP Server — expose QodeAssist's project-aware tools to external MCP clients (Claude Code, VS Code, Claude Desktop via bridge)
• MCP Client Hub — connect QodeAssist to external MCP servers and use their tools in Chat and Quick Refactor (authenticated MCP servers are not supported yet)
• File Context — attach files and images to your messages for richer prompts
• Many Providers — Ollama, llama.cpp, LM Studio (Chat + Responses), Claude, OpenAI (Chat + Responses), Google AI, Mistral, Codestral, OpenRouter, Qwen (OpenAI + Responses), DeepSeek, any OpenAI-compatible endpoint
• Reasoning / Thinking — streamed chain-of-thought is shown for reasoning models across Claude, Google, OpenAI Responses, and any OpenAI-compatible endpoint that returns reasoning_content (DeepSeek, Qwen QwQ/Qwen3-Thinking, LM Studio, OpenRouter, …)
• Customizable — per-project and global agent skills, reusable refactor templates, full prompt-template control

Code completion: (click to expand)

Quick refactor in code: (click to expand)

Chat View Mode: (click to expand)

Multiline Code completion: (click to expand)

Chat with LLM models in side panels: (click to expand)

Chat with LLM models in bottom panel: (click to expand)

Chat in addtional window: (click to expand)

Automatic syncing with open editor files: (click to expand)

Example how tools works: (click to expand)

Install plugin to QtCreator

Method 1: Using the Extension Registry (Recommended)

You can install and update QodeAssist directly from within Qt Creator by adding the QodeAssist registry as an external extension repository.

1. Open the Extensions page (Qt Creator → Extensions) and switch to the Browser tab
2. Enable Use External Repository
3. Next to Repository URLs, click Add and paste the registry archive URL matching your Qt Creator version:
   • Latest (up to date to QtCreator release): https://github.com/Palm1r/extension-registry/archive/refs/heads/qodeassist.tar.gz
   • QtC 20: https://github.com/Palm1r/extension-registry/archive/refs/heads/qodeassist-qtc20.tar.gz
   • QtC 19: https://github.com/Palm1r/extension-registry/archive/refs/heads/qodeassist-qtc19.tar.gz
   • QtC 18: https://github.com/Palm1r/extension-registry/archive/refs/heads/qodeassist-qtc18.tar.gz

Example of extension registry: (click to expand)

4. Click Apply — QodeAssist will appear in the extensions list, where you can Install it
5. Updates can be installed from the same screen when a new version is published

Note: This is an external repository not maintained by The Qt Company. By adding it you accept responsibility for managing the associated risks, as stated in the Extensions page.

Method 2: Manual Installation

1. Install Latest Qt Creator
2. Download the QodeAssist plugin for your Qt Creator
   • Remove old version plugin if already was installed
     • on macOS for QtCreator 16: ~/Library/Application Support/QtProject/Qt Creator/plugins/16.0.0/petrmironychev.qodeassist
     • on windows for QtCreator 16: C:\Users<user>\AppData\Local\QtProject\qtcreator\plugins\16.0.0\petrmironychev.qodeassist\lib\qtcreator\plugins
3. Launch Qt Creator and install the plugin:
   • Go to:
     • MacOS: Qt Creator -> About Plugins...
     • Windows\Linux: Help -> About Plugins...
   • Click on "Install Plugin..."
   • Select the downloaded QodeAssist plugin archive file

Configuration

Quick Setup (Recommended for Beginners)

The Quick Setup feature provides one-click configuration for popular cloud AI models. Get started in 3 easy steps:

Quick setup: (click to expand)

1. Open QodeAssist Settings
2. Select a Preset - Choose from the Quick Setup dropdown:
   • Anthropic Claude (Sonnet 4.5, Haiku 4.5, Opus 4.5)
   • OpenAI (gpt-5.2-codex)
   • Mistral AI (Codestral 2501)
   • Google AI (Gemini 2.5 Flash)
   • Qwen (Qwen3.6 Plus, Qwen3.7 Max)
   • DeepSeek (DeepSeek V4 Flash, DeepSeek V4 Pro)
3. Configure API Key - Click "Configure API Key" button and enter your API key in Provider Settings

All settings (provider, model, template, URL) are configured automatically. Just add your API key and you're ready to go!

Manual Provider Configuration

For advanced users or local models, choose your preferred provider and follow the detailed configuration guide:

Local providers:

• Ollama — native Ollama API
• Ollama (OpenAI-compatible) — Ollama's /v1 endpoint for tool-calling models
• llama.cpp — local llama-server
• LM Studio — OpenAI-compatible Chat API
• LM Studio (Responses API) — newer models that require the Responses endpoint

Cloud providers:

• Anthropic Claude — manual setup guide
• OpenAI — Chat Completions and Responses API
• Mistral AI / Codestral
• Google AI — Gemini
• Qwen (Alibaba) — DashScope OpenAI-compatible Chat and Responses endpoints
• DeepSeek — deepseek-chat and deepseek-reasoner (reasoning shown as thinking)
• OpenAI-compatible — OpenRouter and any custom endpoint

Recommended Models for Best Experience

For optimal coding assistance, we recommend using these top-tier models:

Best for Code Completion & Refactoring:

• Claude 4.5 Haiku or Sonnet (Anthropic)
• GPT-5.1-codex or codex-mini (OpenAI Responses API)
• Codestral (Mistral)

Best for Chat Assistant:

• Claude 4.5 Sonnet (Anthropic) - Outstanding reasoning and natural conversation flow
• GPT-5.1-codex (OpenAI Responses API) - Latest model with advanced capabilities
• Gemini 2.5 or 3.0 (Google AI) - Latest models from Google
• Mistral large (Mistral) - Fast and capable

Local models:

• Qwen3-coder (Qwen) - Best local models

Additional Configuration

• Chat Summarization - Compress conversations to save context tokens
• Ignoring Files - Exclude files from context using .qodeassistignore

Features

Code Completion

• AI-powered intelligent code completion
• Support for C++ and QML
• Context-aware suggestions
• Multiline completions

Completion Trigger Modes

QodeAssist offers two trigger modes for code completion:

Hint-based

• Shows a hint indicator near cursor when you type 3+ characters
• Press Space (or custom key) to request completion
• Best for: Paid APIs (Claude, OpenAI), conscious control
• Benefits: No unexpected API charges, full control over requests, no workflow interruption
• Visual: Clear indicator shows when completion is ready

Automatic(Default)

• Automatically requests completion after typing threshold
• Works immediately without additional keypresses
• Best for: Local models (Ollama, llama.cpp), maximum automation
• Benefits: Hands-free experience, instant suggestions

💡 Tip: Start with Hint-based to avoid unexpected costs. Switch to Automatic if using free local models.

Configure in: Tools → Options → QodeAssist → Code Completion → General Settings

Chat Assistant

• Multiple chat panels: side panel, bottom panel, and popup window
• Chat history with auto-save and restore
• Token usage monitoring
• Chat Summarization - Compress long conversations into AI-generated summaries
• File Context - Attach files for better context
• Extended thinking / reasoning mode - shows streamed chain-of-thought for reasoning models (Claude, Google, OpenAI Responses, and OpenAI-compatible endpoints returning reasoning_content such as DeepSeek, Qwen, LM Studio, OpenRouter)

Quick Refactoring

• Inline code refactoring directly in the editor with AI assistance
• Custom instructions library with search and autocomplete
• Create, edit, and manage reusable refactoring templates
• Combine base instructions with specific details
• Learn more

Tools & Function Calling

Chat and Quick Refactor can call tools to inspect and modify your project. Each tool can be individually enabled/disabled in settings.

Skills

Agent Skills package specialized instructions and workflows into reusable folders the AI loads on demand. QodeAssist implements the open Agent Skills format, so skills authored for Claude Code, Cursor, or other agents work as-is.

A skill is a folder containing a SKILL.md file — YAML frontmatter (name, description) plus Markdown instructions:

my-skill/
└── SKILL.md

---
name: my-skill
description: What the skill does and when to use it.
---

# My Skill

Step-by-step instructions for the task...

Where skills are discovered:

• Project skills — project-relative subdirectories (default .qodeassist/skills/ and .claude/skills/), configured in Projects → QodeAssist → Skills. Project skills win over global ones on a name collision.
• Global skills — absolute directories shared across all projects (default includes ~/.claude/skills/), configured in Tools → Options → QodeAssist → Skills.

Both settings pages show the list of currently discovered skills.

How skills are used in Chat:

• Automatically — each skill's name and description is added to the system prompt; when a request matches, the model loads the full instructions via the load_skill tool (requires a tool-calling model).
• Explicitly — type / in the chat input and pick a skill from the popup; its instructions are injected into that one message. Works with any model.
• Always-on — a skill whose frontmatter has metadata: always-on: "true" is injected into every chat request automatically.

Enable or disable the whole feature in Tools → Options → QodeAssist → Skills.

MCP Server

QodeAssist can run an MCP (Model Context Protocol) server on localhost, exposing the tools above to external clients — so you can use QodeAssist's project awareness from Claude Code CLI, VS Code, Cursor, Claude Desktop, or any other MCP-capable client.

• Enable in Tools → Options → QodeAssist → MCP Server
• Transport: HTTP + SSE by default; a stdio bridge is provided for clients that only speak stdio (e.g. Claude Desktop)
• Ready-to-copy snippets for Claude Code, VS Code, and the bridge are available via the "Show connection instructions" button in settings

MCP Client Hub

QodeAssist can also act as an MCP client, connecting to external MCP servers and making their tools available to Chat and Quick Refactor alongside the built-in ones.

• Configure servers in Tools → Options → QodeAssist → MCP Client
• Transports: stdio and HTTP/SSE
• Limitation: authenticated MCP servers (OAuth / token-protected) are not supported yet — only servers that accept unauthenticated local connections work for now

Context Layers

QodeAssist uses a flexible prompt composition system that adapts to different contexts. Here's how prompts are constructed for each feature:

┌─────────────────────────────────────────────────────────────────────────────┐
│                         CODE COMPLETION (FIM Models)                        │
├─────────────────────────────────────────────────────────────────────────────┤
│  Examples: Codestral, Qwen2.5-Coder, DeepSeek-Coder                        │
│                                                                              │
│  1. System Prompt (from Code Completion Settings - FIM variant)            │
│  2. Open Files Context (optional, if enabled):                             │
│     └─ Currently open editor files                                         │
│  3. Code Context:                                                           │
│     ├─ Code before cursor (prefix)                                         │
│     └─ Code after cursor (suffix)                                          │
│                                                                              │
│  Final Prompt: FIM_Template(Prefix: SystemPrompt + OpenFiles +             │
│                                     CodeBefore,                             │
│                             Suffix: CodeAfter)                              │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                     CODE COMPLETION (Non-FIM/Chat Models)                   │
├─────────────────────────────────────────────────────────────────────────────┤
│  Examples: DeepSeek-Coder-Instruct, Qwen2.5-Coder-Instruct                 │
│                                                                              │
│  1. System Prompt (from Code Completion Settings - Non-FIM variant)        │
│     └─ Includes response formatting instructions                           │
│  2. Open Files Context (optional, if enabled):                             │
│     └─ Currently open editor files                                         │
│  3. Code Context:                                                           │
│     ├─ File information (language, path)                                   │
│     ├─ Code before cursor                                                  │
│     ├─ <cursor> marker                                                     │
│     └─ Code after cursor                                                   │
│  4. User Message: "Complete the code at cursor position"                   │
│                                                                              │
│  Final Prompt: [System: SystemPrompt]                                      │
│                [User: OpenFiles + Context + CompletionRequest]              │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                            CHAT ASSISTANT                                   │
├─────────────────────────────────────────────────────────────────────────────┤
│  1. System Prompt (from Chat Assistant Settings)                           │
│  2. Project Info (active project name, source root, build directory)       │
│  3. Skills (always-on bodies + catalog + /invoked skills)                  │
│  4. File Context (optional):                                               │
│     └─ Attached files (manual)                                             │
│  5. Tool Definitions (if enabled):                                         │
│     ├─ ReadProjectFileByName                                               │
│     ├─ ListProjectFiles                                                    │
│     ├─ SearchInProject                                                     │
│     └─ GetIssuesList                                                       │
│  6. Conversation History                                                    │
│  7. User Message                                                            │
│                                                                              │
│  Final Prompt: [System: SystemPrompt + ProjectInfo + Skills + Tools]       │
│                [History: Previous messages]                                 │
│                [User: FileContext + UserMessage]                            │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                         QUICK REFACTORING                                   │
├─────────────────────────────────────────────────────────────────────────────┤
│  1. System Prompt (from Quick Refactor Settings)                           │
│  2. Code Context:                                                           │
│     ├─ File information (language, path)                                   │
│     ├─ Code before selection (configurable amount)                         │
│     ├─ <selection_start> marker                                            │
│     ├─ Selected code (or current line)                                     │
│     ├─ <selection_end> marker                                              │
│     ├─ <cursor> marker (position within selection)                         │
│     └─ Code after selection (configurable amount)                          │
│  3. Refactor Instruction:                                                   │
│     ├─ Built-in (e.g., "Improve Code", "Alternative Solution")             │
│     ├─ Custom Instruction (from library)                                   │
│     │  └─ ~/.config/QtProject/qtcreator/qodeassist/                        │
│     │      quick_refactor/instructions/*.json                              │
│     └─ Additional Details (optional user input)                            │
│  4. Tool Definitions (if enabled)                                          │
│                                                                              │
│  Final Prompt: [System: SystemPrompt]                                      │
│                [User: Context + Markers + Instruction + Details]            │
└─────────────────────────────────────────────────────────────────────────────┘

Key Points

• System Prompts are configured independently for each feature in Settings
• Skills provide reusable, project- or globally-scoped instructions for Chat: always-on skills are injected into the system prompt, others are invoked with /skill-name
• FIM vs Non-FIM models for code completion use different System Prompts:
  • FIM models: Direct completion prompt
  • Non-FIM models: Prompt includes response formatting instructions
• Quick Refactor has its own provider/model configuration, independent from Chat
• Custom Instructions provide reusable templates that can be augmented with specific details
• Tool Calling is available for Chat and Quick Refactor when enabled

See the Quick Refactoring Guide for more details.

QtCreator Version Compatibility

Hotkeys

All hotkeys can be customized in Qt Creator Settings. Default hotkeys:

Troubleshooting

Having issues with QodeAssist? Check our detailed troubleshooting guide for:

• Connection issues and provider URLs
• Model and template compatibility
• Platform-specific issues (Linux, macOS, Windows)
• Resetting settings to defaults
• Common problems and solutions

Development Progress

• Code completion (FIM and chat models)
• Chat assistant (side / bottom / detached panels)
• Quick refactoring with custom-instructions library
• Diff sharing with models
• Tools / function calling (file I/O, build, terminal, diagnostics)
• Agent Skills (project + global directories, /skill commands, always-on, load_skill tool)
• MCP (Model Context Protocol) — QodeAssist as a server
• MCP — QodeAssist as a client (consume external MCP tools; authenticated MCP servers not yet supported)
• Full project source sharing
• Additional provider support

Every contribution, no matter how small, is greatly appreciated and helps keep the project alive!

Related Projects

• LLMQore — the standalone LLM-core library extracted from QodeAssist, reusable in other Qt/C++ projects

How to Build

Prerequisites

• CMake 3.16+
• C++20 compatible compiler
• Qt Creator development files

Build Steps

1. Create a build directory:

mkdir build && cd build

2. Configure and build:

cmake -DCMAKE_PREFIX_PATH=<path_to_qtcreator> -DCMAKE_BUILD_TYPE=RelWithDebInfo <path_to_plugin_source>
cmake --build .

Path specifications:

• <path_to_qtcreator>:
  • Windows/Linux: Qt Creator build directory or combined binary package
  • macOS: Qt Creator.app/Contents/Resources/
• <path_to_plugin_source>: Path to this plugin directory

For Contributors

Code Style

• QML: Follow QML Coding Guide by @Furkanzmc
• C++: Use .clang-format configuration in the project root
• Run formatting before submitting PRs

Development Guidelines

For detailed development guidelines, architecture patterns, and best practices, see the project workspace rules.

License

QodeAssist is licensed under the GNU General Public License v3.0 (see LICENSE), with additional attribution terms under GPLv3 Section 7(b).

You are free to use, modify, and redistribute QodeAssist under GPL-3.0, but you must preserve the original author attribution, copyright notices, and project identification — including in source file headers, the plugin metadata (QodeAssist.json.in), and the About dialog or equivalent user-facing identification. Modified versions must be clearly marked as different from the original.

Commercial licensing

QodeAssist is also available under a separate commercial license for use in proprietary or closed-source products without GPL-3.0 obligations. For commercial licensing inquiries, contact palm1r-github-dev@pm.me.

Qt Creator components and attributions

QodeAssist is a plugin for Qt Creator and incorporates certain components (plugin templates, API headers, and related boilerplate) originating from Qt Creator, which are copyright (C) The Qt Company Ltd.

These components are provided by The Qt Company under the GNU General Public License version 3, annotated with The Qt Company GPL Exception 1.0. This exception permits the development and distribution of Qt Creator plugins under licenses of the plugin author's own choosing, notwithstanding the GPL's general linking requirements. It is this exception that allows QodeAssist to be offered under both GPL-3.0 and a separate commercial license.

The original copyright and license notices of The Qt Company are preserved in the relevant source files and must not be removed.

For Qt Creator's licensing terms, see LICENSE.GPL3-EXCEPT.