Qiskit Code Assistant

Qiskit Code Assistant a pour but de rendre l'informatique quantique plus accessible aux nouveaux utilisateurs de Qiskit et d'améliorer l'expérience de codage des utilisateurs actuels. C'est un assistant de code par IA générative propulsé par watsonx. Il est entraîné à partir de millions de tokens de texte issus du SDK Qiskit, d'années d'exemples de code Qiskit, et des fonctionnalités d'IBM Quantum®. Qiskit Code Assistant peut améliorer ton flux de développement quantique en proposant des suggestions générées par LLM basées sur les modèles IBM Granite, qui intègrent les dernières fonctionnalités d'IBM®.

Remarques

Il s'agit d'une fonctionnalité expérimentale disponible pour les utilisateurs du plan IBM Quantum Premium inscrits sur la nouvelle IBM Quantum Platform.
Qiskit Code Assistant est en version préliminaire et est susceptible d'évoluer.
Si tu as des retours ou souhaites contacter l'équipe de développement, utilise le canal Qiskit Slack Workspace ou les dépôts GitHub publics associés.

Fonctionnalités

Les fonctionnalités suivantes sont incluses dans les extensions pour Visual Studio Code (VS Code) et les éditeurs compatibles, ainsi que pour JupyterLab :

Accélère la génération de code Qiskit en exploitant l'IA générative à partir de modèles spécialisés dans la génération de code Qiskit.
Permet des prompts abstraits et spécifiques pour générer des recommandations.
Présente des suggestions que tu peux examiner, accepter ou rejeter.
Prend en charge les fichiers Python et les notebooks Jupyter.
Inclut des garde-fous pour éviter de répondre à des questions présentant un risque potentiel pour les utilisateurs, comme les discours haineux.

Pour intégrer Qiskit Code Assistant directement dans ton environnement de développement, suis les instructions dans la rubrique appropriée :

Le Grand Modèle de Langage (LLM) derrière Qiskit Code Assistant

Pour fournir des suggestions de code, Qiskit Code Assistant utilise un Grand Modèle de Langage (LLM). Dans ce cas, Qiskit Code Assistant s'appuie actuellement sur le modèle mistral-small-3.2-24b-qiskit, construit sur le modèle Mistral-Small-3.2-24B-Qiskit. Le modèle mistral-small-3.2-24b-qiskit améliore les capacités de génération de code Qiskit du modèle Mistral-Small-3.2-24B-Instruct-2506 grâce à un pré-entraînement étendu et à un affinage sur des données Qiskit de haute qualité, ainsi que sur des commits Python et des conversations. Pour plus d'informations sur la famille de modèles Mistral AI, consulte la documentation Mistral AI. Pour plus de détails sur les modèles .*-qiskit, voir Qiskit Code Assistant : Training LLMs for generating Quantum Computing Code.

Nos LLMs spécialisés pour Qiskit sont également disponibles en tant que modèles open source. Consulte tous les modèles disponibles sur https://huggingface.co/Qiskit.

Les benchmarks Qiskit HumanEval et Qiskit HumanEval Hard

Pour tester le modèle mistral-small-3.2-24b-qiskit et d'autres modèles, nous avons collaboré avec des Qiskit Advocates et des experts pour créer les benchmarks basés sur l'exécution appelés Qiskit HumanEval (QHE) et Qiskit HumanEval Hard (QHE Hard), et les avons appliqués aux modèles. Ces benchmarks sont similaires à HumanEval, et comprennent plusieurs problèmes de code complexes à résoudre, tous basés sur les bibliothèques officielles de Qiskit.

Les benchmarks sont composés d'environ 150 tests, chacun constitué d'une définition de fonction suivie d'une docstring qui détaille la tâche que le modèle doit résoudre. Chaque exemple inclut également une solution canonique de référence, ainsi que des tests unitaires, pour évaluer la correction des solutions générées. Il existe trois niveaux de difficulté pour les tests : basique, intermédiaire et difficile. Le benchmark Qiskit HumanEval Hard est une variante du Qiskit HumanEval, mais supprime les informations relatives aux imports de code, de sorte que le LLM doit déterminer les bons imports de méthodes ou de classes. Ce changement rend l'ensemble de données bien plus difficile pour les LLMs, selon nos tests et nos résultats initiaux.

Les jeux de données Qiskit HumanEval et Qiskit HumanEval Hard sont disponibles sur ces sites : Qiskit HumanEval et Qiskit HumanEval. Tu peux contribuer au développement de ces benchmarks sur le dépôt GitHub.

Plus d'informations et citations

Pour en savoir plus sur Qiskit Code Assistant, les benchmarks Qiskit HumanEval ou Qiskit HumanEval Hard, et les citer dans tes publications scientifiques, consulte ces citations recommandées :

@misc{2405.19495,
Author = {Nicolas Dupuis and Luca Buratti and Sanjay Vishwakarma and Aitana Viudes Forrat and David Kremer and Ismael Faro and Ruchir Puri and Juan Cruz-Benito},
Title = {Qiskit Code Assistant: Training LLMs for generating Quantum Computing Code},
Year = {2024},
Eprint = {arXiv:2405.19495},
}

@misc{2406.14712,
Author = {Sanjay Vishwakarma and Francis Harkins and Siddharth Golecha and Vishal Sharathchandra Bajpe and Nicolas Dupuis and Luca Buratti and David Kremer and Ismael Faro and Ruchir Puri and Juan Cruz-Benito},
Title = {Qiskit HumanEval: An Evaluation Benchmark For Quantum Code Generative Models},
Year = {2024},
Eprint = {arXiv:2406.14712},
}

@misc{2508.20907,
Author = {Nicolas Dupuis and Adarsh Tiwari and Youssef Mroueh and David Kremer and Ismael Faro and Juan Cruz-Benito},
Title = {Quantum Verifiable Rewards for Post-Training Qiskit Code Assistant},
Year = {2025},
Eprint = {arXiv:2508.20907},
}

Utiliser Qiskit Code Assistant en mode local

Apprends à installer, configurer et utiliser n'importe quel modèle Qiskit Code Assistant sur ta machine locale.

Remarques

Qiskit Code Assistant est en version préliminaire et est susceptible d'évoluer.
Si tu as des retours ou souhaites contacter l'équipe de développement, utilise le canal Qiskit Slack Workspace ou les dépôts GitHub publics associés.

Démarrage rapide (recommandé)

La façon la plus simple de démarrer avec Qiskit Code Assistant en mode local est d'utiliser les scripts de configuration automatisés pour l'extension VS Code ou JupyterLab. Ces scripts installeront automatiquement Ollama pour exécuter les LLMs, téléchargeront le modèle recommandé et configureront l'extension pour toi.

Configuration de l'extension VS Code

Exécute la commande suivante dans ton terminal :

bash <(curl -fsSL https://raw.githubusercontent.com/Qiskit/qiskit-code-assistant-vscode/main/setup_local.sh)

Ce script effectue les étapes suivantes :

Installer Ollama (s'il n'est pas déjà installé)
Télécharger et configurer le modèle Qiskit Code Assistant recommandé
Configurer l'extension VS Code pour fonctionner avec ton déploiement local

Configuration de l'extension JupyterLab

Exécute la commande suivante dans ton terminal :

bash <(curl -fsSL https://raw.githubusercontent.com/Qiskit/qiskit-code-assistant-jupyterlab/main/setup_local.sh)

Ce script va :

Installer Ollama (s'il n'est pas déjà installé)
Télécharger et configurer le modèle Qiskit Code Assistant recommandé
Configurer l'extension JupyterLab pour fonctionner avec ton déploiement local

Modèles disponibles

Modèles actuels

Voici les derniers modèles recommandés pour une utilisation avec Qiskit Code Assistant :

Qiskit/mistral-small-3.2-24b-qiskit - Publié en octobre 2025
qiskit/qwen2.5-coder-14b-qiskit - Publié en juin 2025
qiskit/granite-3.3-8b-qiskit - Publié en juin 2025
qiskit/granite-3.2-8b-qiskit - Publié en juin 2025

Modèles GGUF (recommandés pour les environnements personnels/laptops)

Les modèles au format GGUF sont optimisés pour une utilisation locale et nécessitent moins de ressources de calcul :

mistral-small-3.2-24b-qiskit-GGUF – Publié en octobre 2025
Entraîné avec des données Qiskit jusqu'à la version 2.1
qiskit/qwen2.5-coder-14b-qiskit-GGUF – Publié en juin 2025
Entraîné avec des données Qiskit jusqu'à la version 2.0
qiskit/granite-3.3-8b-qiskit-GGUF – Publié en juin 2025
Entraîné avec des données Qiskit jusqu'à la version 2.0
qiskit/granite-3.2-8b-qiskit-GGUF – Publié en juin 2025
Entraîné avec des données Qiskit jusqu'à la version 2.0

Les modèles Qiskit Code Assistant open source sont disponibles au format safetensors ou GGUF et peuvent être téléchargés depuis Hugging Face comme expliqué ci-dessous.

Versions de Qiskit utilisées pour l'entraînement

Modèle						Métriques de benchmark					Date de publication	Entraîné sur la version Qiskit
	QiskitHumanEval-Hard	QiskitHumanEval	HumanEval	ASDiv	MathQA	SciQ	MBPP	IFEval	CrowsPairs (English)	TruthfulQA (MC1 acc)
mistral-small-3.2-24b-qiskit	32.45	47.02	77.49	3.77	49.68	97.50	64.00	48.44	67.08	39.41	Janvier 2026	2.2
qwen2.5-coder-14b-qiskit	25.17	49.01	91.46	4.21	53.90	97.00	77.60	49.64	65.18	37.82	Juin 2025	2.0
granite-3.3-8b-qiskit	14.57	27.15	62.80	0.48	38.66	93.30	52.40	59.71	59.75	39.05	Juin 2025	2.0
granite-3.2-8b-qiskit	9.93	24.50	57.32	0.09	41.41	96.30	51.80	60.79	66.79	40.51	Juin 2025	2.0
granite-8b-qiskit-rc-0.10	15.89	38.41	59.76	—	—	—	—	—	—	—	Février 2025	1.3
granite-8b-qiskit	17.88	44.37	53.66	—	—	—	—	—	—	—	Novembre 2024	1.2

Remarque : tous les modèles listés dans le tableau de benchmark ont été évalués en utilisant leur system prompt respectif, défini dans leur modèle Hugging Face.

Modèles dépréciés

Ces modèles ne sont plus activement maintenus mais restent disponibles :

qiskit/granite-8b-qiskit-rc-0.10 - Publié en février 2025 (déprécié)
qiskit/granite-8b-qiskit - Publié en novembre 2024 (déprécié)

Configuration avancée

Si tu préfères configurer manuellement ton installation locale ou si tu as besoin de plus de contrôle sur le processus d'installation, développe les sections ci-dessous.

Télécharger depuis le site Hugging Face

Suis ces étapes pour télécharger n'importe quel modèle lié à Qiskit Code Assistant depuis le site Hugging Face :

Navigue vers la page du modèle Qiskit souhaité sur Hugging Face.
Va dans l'onglet Files and Versions et télécharge les fichiers du modèle au format safetensors ou GGUF.

Télécharger avec la CLI Hugging Face

Pour télécharger n'importe quel modèle Qiskit Code Assistant disponible à l'aide de la CLI Hugging Face, suis ces étapes :

Installe la CLI Hugging Face
Connecte-toi à ton compte Hugging Face
```
huggingface-cli login
```

Télécharge le modèle de ton choix depuis la liste précédente

huggingface-cli download <HF REPO NAME> <MODEL PATH> --local-dir <LOCAL PATH>

Déployer manuellement les modèles Qiskit Code Assistant en local via Ollama

Il existe plusieurs façons de déployer et d'interagir avec le modèle Qiskit Code Assistant téléchargé. Ce guide montre comment utiliser Ollama comme suit : soit avec l'application Ollama via l'intégration Hugging Face Hub ou un modèle local, soit avec le package llama-cpp-python.

Utiliser l'application Ollama

L'application Ollama offre une solution simple pour exécuter les LLMs localement. Elle est facile à utiliser, avec une CLI qui rend l'ensemble du processus de configuration, la gestion des modèles et l'interaction assez simples. Elle est idéale pour une expérimentation rapide et pour les utilisateurs qui souhaitent gérer moins de détails techniques.

Installer Ollama

Télécharge l'application Ollama
Installe le fichier téléchargé
Lance l'application Ollama installée

info
L'application fonctionne correctement lorsque l'icône Ollama apparaît dans la barre de menu du bureau. Tu peux également vérifier que le service est en cours d'exécution en accédant à http://localhost:11434/.
Essaie Ollama dans ton terminal et commence à exécuter des modèles. Par exemple :
```
ollama run hf.co/Qiskit/Qwen2.5-Coder-14B-Qiskit
```

Configurer Ollama avec l'intégration Hugging Face Hub

L'intégration Ollama/Hugging Face Hub permet d'interagir avec les modèles hébergés sur le Hugging Face Hub sans avoir à créer un nouveau modelfile ni à télécharger manuellement les fichiers GGUF ou safetensors. Les fichiers template et params par défaut sont déjà inclus pour le modèle sur le Hugging Face Hub.

Assure-toi que l'application Ollama est en cours d'exécution.
Va sur la page du modèle souhaité et copie l'URL. Par exemple, https://huggingface.co/Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF.

Depuis ton terminal, exécute la commande :

ollama run hf.co/Qiskit/Qwen2.5-Coder-14B-Qiskit

Tu peux utiliser le modèle hf.co/Qiskit/Qwen2.5-Coder-14B-Qiskit ou n'importe lequel des autres modèles GGUF officiels recommandés hf.co/Qiskit/mistral-small-3.2-24b-qiskit-GGUF ou hf.co/Qiskit/granite-3.3-8b-qiskit-GGUF.

Configurer Ollama avec un modèle GGUF Qiskit Code Assistant téléchargé manuellement

Si tu as téléchargé manuellement un modèle GGUF comme https://huggingface.co/Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF et que tu souhaites expérimenter avec différents templates et paramètres, tu peux suivre ces étapes pour le charger dans ton application Ollama locale.

Crée un Modelfile avec le contenu suivant et assure-toi de mettre à jour <PATH-TO-GGUF-FILE> avec le chemin réel de ton modèle téléchargé.

FROM <PATH-TO-GGUF-FILE>
TEMPLATE """{{ if .System }}
System:
{{ .System }}

{{ end }}{{ if .Prompt }}Question:
{{ .Prompt }}

{{ end }}Answer:
```python{{ .Response }}
"""

PARAMETER stop "Question:"
PARAMETER stop "Answer:"
PARAMETER stop "System:"
PARAMETER stop "```"

PARAMETER temperature 0
PARAMETER top_k 1

Run the following command to create a custom model instance based on the Modelfile.
```
ollama create Qwen2.5-Coder-14B-Qiskit -f ./path-to-model-file
```
remarque
This process may take some time for Ollama to read the model file, initialize the model instance, and configure it according to the specifications provided.

Run the Qiskit Code Assistant model manually downloaded in Ollama

After the Qwen2.5-Coder-14B-Qiskit model has been set up in Ollama, run the following command to launch the model and interact with it in the terminal (in chat mode).

ollama run Qwen2.5-Coder-14B-Qiskit

Some useful commands:

ollama list - List models on your computer
ollama rm Qwen2.5-Coder-14B-Qiskit - Delete the model
ollama show Qwen2.5-Coder-14B-Qiskit - Show model information
ollama stop Qwen2.5-Coder-14B-Qiskit - Stop a model that is currently running
ollama ps - List which models are currently loaded

Manually deploy the Qiskit Code Assistant models in local through the llama-cpp-python package

An alternative to the Ollama application is the llama-cpp-python package, which is a Python binding for llama.cpp. It gives you more control and flexibility to run the GGUF model locally, and is ideal for users who wish to integrate the local model in their workflows and Python applications.

Install llama-cpp-python
Interact with the model from within your application using llama_cpp. For example:

from llama_cpp import Llama

model_path = <PATH-TO-GGUF-FILE>

model = Llama(
        model_path,
        seed=17,
        n_ctx=10000,
        n_gpu_layers=37, # to offload in gpu, but put 0 if all in cpu
    )

input = 'Generate a quantum circuit with 2 qubits'
raw_pred = model(input)["choices"][0]["text"]

You can also add text generation parameters to the model to customize the inference:

generation_kwargs = {
        "max_tokens": 512,
        "echo": False, # Echo the prompt in the output
        "top_k": 1
    }

raw_pred = model(input, **generation_kwargs)["choices"][0]["text"]

Manually deploy the Qiskit Code Assistant models in local through llama.cpp

Use the `llama.cpp` library

Another alternative is to use llama.cpp, an open-source library for performing LLM inference on a CPU with minimal setup. It provides low-level control over the model execution and is typically run from the command line, pointing to a local GGUF model file.

There are several ways to install llama.cpp on your machine:

Install llama.cpp using brew, nix, or winget
Run with Docker: See out the Docker documentation by llama.cpp team
Download pre-built binaries from the releases page
Build from source by cloning this repository

Once installed, you can use llama.cpp to interact with GGUF models in conversation mode as follows:

# Use a local model file
llama-cli -m my_model.gguf -cnv

# Or download and run a model directly from Hugging Face
llama-cli -hf Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF -cnv

You can also launch an OpenAI-compatible API server for the model in the following way:

llama-server -hf Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF

Advanced parameters

With the llama-cli program, you can control the model generation using command-line options. For example, you can provide an initial “system” prompt using the -p/--prompt flag. In conversation mode (-cnv), this initial prompt acts as the system message. Otherwise, you can simply prepend any desired instruction to your prompt text. You can also adjust sampling parameters - for instance: temperature (--temp), top-k (--top-k), top-p (--top-p), repetition penalty (--repeat-penalty), and the seed to use (--seed). The following is an example invocation using these options:

llama-cli -hf Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF \
  -p "You are a friendly assistant." -cnv \
  --temp 0.7 \
  --top-k 50 \
  --top-p 0.95 \
  --repeat-penalty 1.1 \
  --seed 42

Pour assurer le bon fonctionnement de nos modèles Qiskit, nous recommandons d'utiliser le system prompt fourni dans nos dépôts HF GGUF : system prompt pour mistral-small-3.2-24b-qiskit-GGUF, Qwen2.5-Coder-14B-Qiskit-GGUF, granite-3.3-8b-qiskit-GGUF, et granite-3.2-8b-qiskit-GGUF.

Connecter manuellement les extensions au déploiement local

Utilise l'extension VS Code et l'extension JupyterLab de Qiskit Code Assistant pour interagir avec le modèle Qiskit Code Assistant déployé localement. Une fois que tu as l'application Ollama configurée avec le modèle, tu peux configurer les extensions pour se connecter au service local.

Connecter avec l'extension VS Code de Qiskit Code Assistant

Avec l'extension VS Code de Qiskit Code Assistant, tu peux interagir avec le modèle et effectuer la complétion de code pendant l'écriture de ton code. Cela peut convenir aux utilisateurs qui cherchent de l'aide pour écrire du code Qiskit dans leurs applications Python.

Installe l'extension VS Code de Qiskit Code Assistant.
Dans VS Code, va dans les Paramètres utilisateur et définis Qiskit Code Assistant: Url sur l'URL de ton déploiement Ollama local (par exemple, http://localhost:11434).
Recharge VS Code en allant dans Affichage > Palette de commandes... et en sélectionnant Développeur : Recharger la fenêtre.

Le modèle Qiskit Code Assistant configuré dans Ollama devrait apparaître dans la barre d'état et est alors prêt à utiliser.

Connecter avec l'extension JupyterLab de Qiskit Code Assistant

Avec l'extension JupyterLab de Qiskit Code Assistant, tu peux interagir avec le modèle et effectuer la complétion de code directement dans ton Jupyter Notebook. Les utilisateurs travaillant principalement avec des Jupyter Notebooks peuvent profiter de cette extension pour améliorer leur expérience d'écriture de code Qiskit.

Installe l'extension JupyterLab de Qiskit Code Assistant.
Dans JupyterLab, va dans l'Éditeur de paramètres et définis Qiskit Code Assistant Service API sur l'URL de ton déploiement Ollama local (par exemple, http://localhost:11434).

Le modèle Qiskit Code Assistant configuré dans Ollama devrait apparaître dans la barre d'état et est alors prêt à utiliser.

Prochaines étapes

Recommandations

Installe et utilise les extensions officielles JupyterLab ou VS Code.
Consulte des exemples d'utilisation de Qiskit Code Assistant pour les circuits, la configuration de la suppression d'erreurs, et la transpilation avec des pass managers.

Fonctionnalités​

Le Grand Modèle de Langage (LLM) derrière Qiskit Code Assistant​

Les benchmarks Qiskit HumanEval et Qiskit HumanEval Hard​

Plus d'informations et citations​

Utiliser Qiskit Code Assistant en mode local​

Démarrage rapide (recommandé)​

Configuration de l'extension VS Code​

Configuration de l'extension JupyterLab​

Modèles disponibles​

Modèles actuels​

Modèles GGUF (recommandés pour les environnements personnels/laptops)​

Versions de Qiskit utilisées pour l'entraînement​

Modèles dépréciés​

Configuration avancée​

Utiliser l'application Ollama​

Installer Ollama​

Configurer Ollama avec l'intégration Hugging Face Hub​

Configurer Ollama avec un modèle GGUF Qiskit Code Assistant téléchargé manuellement​

Run the Qiskit Code Assistant model manually downloaded in Ollama​

Use the llama.cpp library​

Advanced parameters​

Connecter avec l'extension VS Code de Qiskit Code Assistant​

Connecter avec l'extension JupyterLab de Qiskit Code Assistant​

Prochaines étapes​