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), and can also run as an MCP server so other clients reuse its project context.

⚠️ Important Notice About Paid Providers

When using paid providers like Claude, OpenRouter or OpenAI-compatible services:

• These services will consume API tokens which may result in charges to your account
• The QodeAssist developer bears no responsibility for any charges incurred
• Please carefully review the provider's pricing and your account settings before use

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

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
• MCP Server — expose QodeAssist's project-aware tools to external MCP clients (Claude Code, VS Code, Claude Desktop via bridge)
• File Context — attach, link, or auto-sync open editor files for richer prompts
• Many Providers — Ollama, llama.cpp, LM Studio (Chat + Responses), Claude, OpenAI (Chat + Responses), Google AI, Mistral, Codestral, OpenRouter, any OpenAI-compatible endpoint
• Customizable — per-project rules (.qodeassist/rules/), agent roles, reusable refactor templates, full prompt-template control

Join our Discord Community to get support and connect with other users!

Code completion: (click to expand)

Quick refactor in code: (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)

QodeAssistUpdater is a command-line utility that automates plugin installation and updates with automatic Qt Creator version detection and checksum verification.

Features:

• Automatic Qt Creator version detection
• Install, update, or remove plugin with single command
• List all available plugin versions
• Install specific plugin version
• Checksum verification
• Non-interactive mode for CI/CD

Installation:

Download pre-built binary from QodeAssistUpdater releases or build from source

Usage:

# Check current status and available updates
./qodeassist-updater --status

# Install latest version
./qodeassist-updater --install

For more information, visit the QodeAssistUpdater repository.

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

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)
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!

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
• OpenAI-compatible — OpenRouter and any custom endpoint

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

• Agent Roles - Create AI personas with specialized system prompts
• Chat Summarization - Compress conversations to save context tokens
• Project Rules - Customize AI behavior for your project
• Ignoring Files - Exclude files from context using .qodeassistignore

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

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

• Multiple chat panels: side panel, bottom panel, and popup window
• Chat history with auto-save and restore
• Token usage monitoring
• Agent Roles - Switch between AI personas (Developer, Reviewer, custom roles)
• Chat Summarization - Compress long conversations into AI-generated summaries
• File Context - Attach or link files for better context
• Automatic syncing with open editor files (optional)
• Extended thinking mode (Claude, other providers in plan) - Enable deeper reasoning for complex tasks

• 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

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

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

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. Project Rules:                                                          │
│     └─ .qodeassist/rules/completion/*.md                                   │
│  3. Open Files Context (optional, if enabled):                             │
│     └─ Currently open editor files                                         │
│  4. Code Context:                                                           │
│     ├─ Code before cursor (prefix)                                         │
│     └─ Code after cursor (suffix)                                          │
│                                                                              │
│  Final Prompt: FIM_Template(Prefix: SystemPrompt + Rules + 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. Project Rules:                                                          │
│     └─ .qodeassist/rules/completion/*.md                                   │
│  3. Open Files Context (optional, if enabled):                             │
│     └─ Currently open editor files                                         │
│  4. Code Context:                                                           │
│     ├─ File information (language, path)                                   │
│     ├─ Code before cursor                                                  │
│     ├─ <cursor> marker                                                     │
│     └─ Code after cursor                                                   │
│  5. User Message: "Complete the code at cursor position"                   │
│                                                                              │
│  Final Prompt: [System: SystemPrompt + Rules]                              │
│                [User: OpenFiles + Context + CompletionRequest]              │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                            CHAT ASSISTANT                                   │
├─────────────────────────────────────────────────────────────────────────────┤
│  1. System Prompt (from Chat Assistant Settings)                           │
│  2. Agent Role (optional, from role selector):                             │
│     └─ Role-specific system prompt (Developer, Reviewer, custom)           │
│  3. Project Rules:                                                          │
│     ├─ .qodeassist/rules/common/*.md                                       │
│     └─ .qodeassist/rules/chat/*.md                                         │
│  4. File Context (optional):                                               │
│     ├─ Attached files (manual)                                             │
│     ├─ Linked files (persistent)                                           │
│     └─ Open editor files (if auto-sync enabled)                            │
│  5. Tool Definitions (if enabled):                                         │
│     ├─ ReadProjectFileByName                                               │
│     ├─ ListProjectFiles                                                    │
│     ├─ SearchInProject                                                     │
│     └─ GetIssuesList                                                       │
│  6. Conversation History                                                    │
│  7. User Message                                                            │
│                                                                              │
│  Final Prompt: [System: SystemPrompt + AgentRole + Rules + Tools]          │
│                [History: Previous messages]                                 │
│                [User: FileContext + UserMessage]                            │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                         QUICK REFACTORING                                   │
├─────────────────────────────────────────────────────────────────────────────┤
│  1. System Prompt (from Quick Refactor Settings)                           │
│  2. Project Rules:                                                          │
│     ├─ .qodeassist/rules/common/*.md                                       │
│     └─ .qodeassist/rules/quickrefactor/*.md                                │
│  3. 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)                          │
│  4. 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)                            │
│  5. Tool Definitions (if enabled)                                          │
│                                                                              │
│  Final Prompt: [System: SystemPrompt + Rules]                              │
│                [User: Context + Markers + Instruction + Details]            │
└─────────────────────────────────────────────────────────────────────────────┘

• Project Rules are automatically loaded from .qodeassist/rules/ directory structure
• System Prompts are configured independently for each feature in Settings
• Agent Roles add role-specific prompts on top of the base system prompt (Chat only)
• 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 Project Rules Documentation, Agent Roles Guide, and Quick Refactoring Guide for more details.

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

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

For additional support, join our Discord Community or check GitHub Issues.

• 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)
• Project-specific rules (.qodeassist/rules/)
• MCP (Model Context Protocol) — QodeAssist as a server
• MCP — QodeAssist as a client (consume external MCP tools)
• Full project source sharing
• Additional provider support

If you find QodeAssist helpful, there are several ways you can support the project:

1. Report Issues: If you encounter any bugs or have suggestions for improvements, please open an issue on our GitHub repository.

2. Contribute: Feel free to submit pull requests with bug fixes or new features.

3. Spread the Word: Star our GitHub repository and share QodeAssist with your fellow developers.

4. Financial Support: If you'd like to support the development financially, you can make a donation using one of the following:

   • Bitcoin (BTC): bc1qndq7f0mpnlya48vk7kugvyqj5w89xrg4wzg68t
   • Ethereum (ETH): 0xA5e8c37c94b24e25F9f1f292a01AF55F03099D8D
   • Litecoin (LTC): ltc1qlrxnk30s2pcjchzx4qrxvdjt5gzuervy5mv0vy
   • USDT (TRC20): THdZrE7d6epW6ry98GA3MLXRjha1DjKtUx

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

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

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

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

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