Zum Hauptinhalt springen
Dieses Projekt befindet sich in der Beta-Phase. Einen Fehler gefunden? GitHub Issue erstellen. Frage oder Idee? In Discussions fragen — wir freuen uns über dein Feedback!
Wie ist die Übersetzungsqualität auf dieser Seite?

Qiskit Code Assistant

Die Qiskit Code Assistant LLMs sollen Quantencomputing für neue Qiskit-Nutzer zugänglicher machen und das Programmiererlebnis für bestehende Nutzer verbessern. Sie wurden mit Millionen von Text-Tokens aus dem Qiskit SDK, jahrelangen Qiskit-Code-Beispielen und IBM Quantum®-Funktionen trainiert. Qiskit Code Assistant kann deinen Quantum-Entwicklungsworkflow unterstützen, indem er LLM-generierte Vorschläge auf Basis von IBM Granite und anderen Open-Source-Modellen anbietet, die die neuesten Funktionen und Features von IBM® beinhalten.

Hinweise

Das Large Language Model (LLM) hinter Qiskit Code Assistant​

Um Code-Vorschläge bereitzustellen, verwendet Qiskit Code Assistant ein Large Language Model (LLM). Konkret basiert Qiskit Code Assistant derzeit auf dem Modell mistral-small-3.2-24b-qiskit, das auf dem Mistral-Small-3.2-24B-Qiskit-Modell aufbaut. Das Modell mistral-small-3.2-24b-qiskit verbessert die Code-Generierungsfähigkeiten des Modells Mistral-Small-3.2-24B-Instruct-2506 für Qiskit durch erweitertes Pretraining und Fine-Tuning auf hochwertigen Qiskit-Daten sowie Python-Commits und Chat. Weitere Informationen zur Mistral-AI-Modellfamilie findest du in der Mistral-AI-Dokumentation. Weitere Details zu den .*-qiskit-Modellen findest du unter Qiskit Code Assistant: Training LLMs for generating Quantum Computing Code.

Unsere auf Qiskit spezialisierten LLMs sind auch als Open-Source-Modelle verfügbar. Alle verfügbaren Modelle findest du unter https://huggingface.co/Qiskit.

Die Qiskit HumanEval- und Qiskit HumanEval Hard-Benchmarks​

Um das Modell mistral-small-3.2-24b-qiskit und andere Modelle zu testen, haben wir mit Qiskit Advocates und Experten zusammengearbeitet, um ausführungsbasierte Benchmarks namens Qiskit HumanEval (QHE) und Qiskit HumanEval Hard (QHE Hard) zu entwickeln und auf den Modellen auszuführen. Diese Benchmarks ähneln HumanEval und enthalten mehrere anspruchsvolle Code-Aufgaben, die alle auf den offiziellen Qiskit-Bibliotheken basieren.

Die Benchmarks bestehen aus etwa 150 Tests, von denen jeder aus einer Funktionsdefinition besteht, gefolgt von einem Docstring, der die Aufgabe beschreibt, die das Modell lösen soll. Jedes Beispiel enthält außerdem eine Referenz-Musterlösung sowie Unit-Tests zur Überprüfung der Korrektheit der generierten Lösungen. Es gibt drei Schwierigkeitsstufen für Tests: einfach, mittel und schwierig. Der Qiskit HumanEval Hard-Benchmark ist eine Variante des Qiskit HumanEval-Benchmarks, entfernt jedoch Informationen zu Code-Imports, sodass das LLM die richtigen Methoden- oder Klassen-Imports selbst herausfinden muss. Diese Änderung macht den Datensatz laut unseren Tests und ersten Ergebnissen deutlich anspruchsvoller für LLMs.

Die Datensätze für Qiskit HumanEval und Qiskit HumanEval Hard sind auf diesen Websites verfügbar: Qiskit HumanEval und Qiskit HumanEval. Du kannst zur Weiterentwicklung dieser Benchmarks im GitHub-Repository beitragen.

Qiskit Code Assistant installieren​

Erfahre, wie du eines der Qiskit Code Assistant-Modelle auf deinem lokalen Rechner installieren, konfigurieren und verwenden kannst.

Von der Hugging Face-Website herunterladen

Folge diesen Schritten, um ein beliebiges Qiskit Code Assistant-Modell von der Hugging Face-Website herunterzuladen:

  1. Navigiere zur gewünschten Qiskit-Modellseite auf Hugging Face.

  2. Gehe zum Tab Files and Versions und lade die Safetensors- oder GGUF-Modelldateien herunter.

Mit der Hugging Face CLI herunterladen

Um eines der verfügbaren Qiskit Code Assistant-Modelle mit der Hugging Face CLI herunterzuladen, folge diesen Schritten:

  1. Installiere die Hugging Face CLI

  2. Melde dich bei deinem Hugging Face-Konto an

    huggingface-cli login

  3. Lade das gewünschte Modell aus der obigen Liste herunter

    huggingface-cli download <HF REPO NAME> <MODEL PATH> --local-dir <LOCAL PATH>
Qiskit Code Assistant-Modelle lokal über Ollama manuell bereitstellen

Es gibt mehrere Möglichkeiten, das heruntergeladene Qiskit Code Assistant-Modell bereitzustellen und damit zu interagieren. Diese Anleitung zeigt die Verwendung von Ollama wie folgt: entweder mit der Ollama-Anwendung über die Hugging Face Hub-Integration oder ein lokales Modell, oder mit dem llama-cpp-python-Paket.

Ollama-Anwendung verwenden​

Die Ollama-Anwendung bietet eine einfache Lösung, um LLMs lokal auszuführen. Sie ist benutzerfreundlich und verfügt über eine CLI, die den gesamten Einrichtungsprozess, die Modellverwaltung und die Interaktion unkompliziert gestaltet. Sie eignet sich ideal für schnelle Experimente und für Nutzer, die möglichst wenig technischen Aufwand betreiben möchten.

Ollama installieren​

  1. Lade die Ollama-Anwendung herunter

  2. Installiere die heruntergeladene Datei

  3. Starte die installierte Ollama-Anwendung

    info

    Die Anwendung läuft erfolgreich, wenn das Ollama-Symbol in der Menüleiste des Desktops erscheint. Du kannst auch überprüfen, ob der Dienst läuft, indem du http://localhost:11434/ aufrufst.

  4. Probiere Ollama in deinem Terminal aus und starte Modelle. Beispiel:

    ollama run hf.co/Qiskit/Qwen2.5-Coder-14B-Qiskit
Ollama mit der Hugging Face Hub-Integration einrichten​

Die Ollama/Hugging Face Hub-Integration ermöglicht die Interaktion mit auf dem Hugging Face Hub gehosteten Modellen, ohne eine neue Modelfile erstellen oder die GGUF- oder Safetensors-Dateien manuell herunterladen zu müssen. Die Standard-template- und params-Dateien sind bereits für das Modell auf dem Hugging Face Hub enthalten.

  1. Stelle sicher, dass die Ollama-Anwendung läuft.

  2. Gehe zur gewünschten Modellseite und kopiere die URL. Zum Beispiel: https://huggingface.co/Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF.

  3. Führe in deinem Terminal den folgenden Befehl aus:

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

Du kannst das Modell hf.co/Qiskit/Qwen2.5-Coder-14B-Qiskit oder eines der anderen aktuell empfohlenen offiziellen GGUF-Modelle hf.co/Qiskit/mistral-small-3.2-24b-qiskit-GGUF oder hf.co/Qiskit/granite-3.3-8b-qiskit-GGUF verwenden.

Ollama mit einem manuell heruntergeladenen Qiskit Code Assistant-GGUF-Modell einrichten​

Wenn du ein GGUF-Modell wie https://huggingface.co/Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF manuell heruntergeladen hast und mit verschiedenen Templates und Parametern experimentieren möchtest, kannst du diese Schritte ausführen, um es in deine lokale Ollama-Anwendung zu laden.

  1. Erstelle eine Modelfile mit folgendem Inhalt und aktualisiere <PATH-TO-GGUF-FILE> mit dem tatsächlichen Pfad zu deinem heruntergeladenen Modell.

    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

  2. Führe den folgenden Befehl aus, um eine benutzerdefinierte Modellinstanz basierend auf der Modelfile zu erstellen.

    ollama create Qwen2.5-Coder-14B-Qiskit -f ./path-to-model-file

    hinweis

    Dieser Vorgang kann einige Zeit dauern, da Ollama die Modelldatei einlesen, die Modellinstanz initialisieren und entsprechend den angegebenen Spezifikationen konfigurieren muss.

Das manuell in Ollama heruntergeladene Qiskit Code Assistant-Modell ausführen​

Nachdem das Modell Qwen2.5-Coder-14B-Qiskit in Ollama eingerichtet wurde, führe den folgenden Befehl aus, um das Modell zu starten und im Terminal damit zu interagieren (im Chat-Modus).

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

Einige nützliche Befehle:

  • ollama list - Modelle auf deinem Computer auflisten

  • ollama rm Qwen2.5-Coder-14B-Qiskit - Das Modell löschen

  • ollama show Qwen2.5-Coder-14B-Qiskit - Modellinformationen anzeigen

  • ollama stop Qwen2.5-Coder-14B-Qiskit - Ein aktuell laufendes Modell stoppen

  • ollama ps - Anzeigen, welche Modelle aktuell geladen sind

Die Qiskit Code Assistant-Modelle lokal über das llama-cpp-python-Paket manuell bereitstellen

Eine Alternative zur Ollama-Anwendung ist das Paket llama-cpp-python, eine Python-Bindung für llama.cpp. Es bietet dir mehr Kontrolle und Flexibilität, um das GGUF-Modell lokal auszuführen, und ist ideal für Nutzer, die das lokale Modell in ihre Workflows und Python-Anwendungen integrieren möchten.

  1. Installiere llama-cpp-python

  2. Interagiere mit dem Modell innerhalb deiner Anwendung mithilfe von llama_cpp. Zum Beispiel:

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"]

Du kannst dem Modell auch Textgenerierungsparameter hinzufügen, um die Inferenz anzupassen:

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"]

Die Qiskit Code Assistant-Modelle lokal über llama.cpp manuell bereitstellen

Die llama.cpp-Bibliothek verwenden​

Eine weitere Alternative ist die Verwendung von llama.cpp, einer Open-Source-Bibliothek zur Durchführung von LLM-Inferenz auf einer CPU mit minimalem Setup. Sie bietet Low-Level-Kontrolle über die Modellausführung und wird üblicherweise über die Kommandozeile ausgeführt, wobei auf eine lokale GGUF-Modelldatei verwiesen wird.

Es gibt mehrere Möglichkeiten, llama.cpp auf deinem Rechner zu installieren:

Nach der Installation kannst du llama.cpp wie folgt verwenden, um im Konversationsmodus mit GGUF-Modellen zu interagieren:


# Use a local model file \{#use-a-local-model-file}
llama-cli -m my_model.gguf -cnv

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

Du kannst außerdem auf folgende Weise einen OpenAI-kompatiblen API-Server für das Modell starten:

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

Erweiterte Parameter​

Mit dem Programm llama-cli kannst du die Modellgenerierung über Kommandozeilenoptionen steuern. Du kannst beispielsweise mit dem Flag -p/--prompt einen anfänglichen „System“-Prompt angeben. Im Konversationsmodus (-cnv) fungiert dieser anfängliche Prompt als Systemnachricht. Andernfalls kannst du deinem Prompt-Text einfach eine beliebige gewünschte Anweisung voranstellen. Du kannst auch Sampling-Parameter anpassen – zum Beispiel: Temperatur (--temp), Top-k (--top-k), Top-p (--top-p), Repetition Penalty (--repeat-penalty) und den zu verwendenden Seed (--seed). Im Folgenden findest du einen Beispielaufruf mit diesen Optionen:

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

Um die einwandfreie Funktionalität unserer Qiskit-Modelle sicherzustellen, empfehlen wir die Verwendung des in unseren HF-GGUF-Repositories bereitgestellten System-Prompts: System-Prompt für mistral-small-3.2-24b-qiskit-GGUF, Qwen2.5-Coder-14B-Qiskit-GGUF, granite-3.3-8b-qiskit-GGUF und granite-3.2-8b-qiskit-GGUF.

Continue (VS Code) manuell verbinden

Continue (VS Code)​

1. Installiere die Erweiterung​

Öffne VS Code, gehe zu Extensions (Cmd+Shift+X), suche nach Continue und installiere es.

2. Öffne die Konfiguration​

Klicke auf das Continue-Symbol in der Seitenleiste, dann auf das Zahnrad-Symbol, oder öffne die Command Palette (Cmd+Shift+P) und führe Continue: Open Config File aus.

Dies öffnet ~/.continue/config.yaml (oder config.json in älteren Versionen).

3. Konfiguriere das Modell​

Füge Folgendes zu config.yaml hinzu:

models:
  - name: Qiskit Code Assistant
    provider: ollama
    model: mistral-small-3.2-24b-qiskit
    apiBase: http://localhost:11434

Dadurch wird das Qiskit-Modell im Chat-Panel (Konversationen in der Seitenleiste, Inline-Q&A) und für Inline-Edit-Befehle verfügbar.

4. Teste es​

  • Chat: Öffne das Continue-Panel in der Seitenleiste und stelle eine Frage (z. B. „Wie erstelle ich einen parametrisierten Circuit in Qiskit?“)

  • Inline Edit: Wähle einen Codeblock aus und drücke Cmd+I (Mac) oder Ctrl+I (Linux/Windows)

Jupyter AI (JupyterLab) manuell verbinden

Jupyter AI (JupyterLab)​

Hinweis: Diese Anleitung behandelt Jupyter AI v2.x.

1. Installiere Jupyter AI und den Ollama-Provider​
pip install "jupyter-ai<3" langchain-ollama

Die Fixierung "jupyter-ai<3" stellt sicher, dass du v2.x erhältst. Das Paket langchain-ollama wird benötigt, damit Jupyter AI Ollama als Provider erkennt. Ohne dieses Paket erscheint Ollama nicht im Einstellungsfenster.

Starte anschließend JupyterLab neu.

2. Konfiguriere das Chat-Modell​

Öffne JupyterLab und klicke auf das Chat-Symbol in der linken Seitenleiste. Im Einstellungsfenster:

  1. Wähle unter Language model Ollama als Provider aus.

  2. Gib mistral-small-3.2-24b-qiskit als Modellnamen ein.

  3. Für Ollama wird kein API-Schlüssel benötigt (lasse das Feld leer).

  4. Klicke auf den Zurück-Pfeil, um mit dem Chatten zu beginnen.

3. Verwende den Magic-Befehl %%ai​

Mit dem Magic-Befehl %%ai kannst du das Modell direkt in Notebook-Zellen abfragen.

%load_ext jupyter_ai_magics

Dann in einer Zelle:

%%ai ollama:mistral-small-3.2-24b-qiskit
Write a function that implements Grover's algorithm using Qiskit

4. Benutzerdefinierter Ollama-Host (optional)​

Standardmäßig verbindet sich Jupyter AI mit http://127.0.0.1:11434. Wenn dein Ollama-Server unter einer anderen Adresse oder einem anderen Port läuft:

In der Chat-Oberfläche: Setze das Feld „Base API URL“ im KI-Einstellungsfenster.

OpenCode (Terminal) manuell verbinden

OpenCode (Terminal)​

1. Installiere OpenCode​
curl -fsSL https://opencode.ai/install | bash

2. Konfiguriere das Qiskit-Modell​

Erstelle eine Datei opencode.json im Stammverzeichnis deines Projekts (oder ~/.config/opencode/opencode.json für eine globale Konfiguration):

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama (local)",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "mistral-small-3.2-24b-qiskit": {
          "name": "Qiskit Code Assistant"
        }
      }
    }
  }
}

3. Wähle das Modell aus​

Starte OpenCode in deinem Projektverzeichnis:

opencode

Führe innerhalb der TUI den Befehl /models aus und wähle Qiskit Code Assistant aus der Liste aus.

4. Teste es​

Stelle direkt im Chat eine Frage, zum Beispiel: „Definiere einen Bell-Circuit und führe ihn mit QiskitRuntimeService aus“

Verfügbare Modelle​

Aktuelle Modelle​

Dies sind die neuesten empfohlenen Modelle für die Verwendung mit Qiskit Code Assistant:

  1. Qiskit/mistral-small-3.2-24b-qiskit - Veröffentlicht im Oktober 2025

  2. Qiskit/Qwen2.5-Coder-14B-Qiskit - Veröffentlicht im Juni 2025

  3. qiskit/granite-3.3-8b-qiskit - Veröffentlicht im Juni 2025

  4. qiskit/granite-3.2-8b-qiskit - Veröffentlicht im Juni 2025

GGUF-Modelle (empfohlen für persönliche Umgebungen/Laptops)​

GGUF-Modelle sind für den lokalen Einsatz optimiert und benötigen weniger Rechenressourcen:

  1. mistral-small-3.2-24b-qiskit-GGUF – Veröffentlicht im Oktober 2025

    Trainiert mit Qiskit-Daten bis Version 2.1

  2. Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF – Veröffentlicht im Juni 2025

    Trainiert mit Qiskit-Daten bis Version 2.0

  3. qiskit/granite-3.3-8b-qiskit-GGUF – Veröffentlicht im Juni 2025

    Trainiert mit Qiskit-Daten bis Version 2.0

  4. qiskit/granite-3.2-8b-qiskit-GGUF – Veröffentlicht im Juni 2025

    Trainiert mit Qiskit-Daten bis Version 2.0

Die Open-Source-Qiskit-Code-Assistant-Modelle sind im Format safetensors oder im GGUF-Dateiformat verfügbar und können wie unten beschrieben von Hugging Face heruntergeladen werden.

Für das Training verwendete Qiskit-Versionen​

Modell     Benchmark-Metriken    VeröffentlichungsdatumTrainiert mit Qiskit-Version
 QiskitHumanEval-HardQiskitHumanEvalHumanEvalASDivMathQASciQMBPPIFEvalCrowsPairs (Englisch)TruthfulQA (MC1 acc)  
mistral-small-3.2-24b-qiskit32.4547.0277.493.7749.6897.5064.0048.4467.0839.41Januar 20262.2
Qwen2.5-Coder-14B-Qiskit25.1749.0191.464.2153.9097.0077.6049.6465.1837.82Juni 20252.0
granite-3.3-8b-qiskit14.5727.1562.800.4838.6693.3052.4059.7159.7539.05Juni 20252.0
granite-3.2-8b-qiskit9.9324.5057.320.0941.4196.3051.8060.7966.7940.51Juni 20252.0
granite-8b-qiskit-rc-0.1015.8938.4159.76———————Februar 20251.3
granite-8b-qiskit17.8844.3753.66———————November 20241.2

Hinweis: Alle in der Benchmark-Tabelle aufgeführten Modelle wurden anhand ihres jeweiligen System-Prompts bewertet, der in ihrem Hugging Face-Modell definiert ist.

Veraltete Modelle​

Diese Modelle werden nicht mehr aktiv gepflegt, sind aber weiterhin verfügbar:

  1. qiskit/granite-8b-qiskit-rc-0.10 - Veröffentlicht im Februar 2025 (veraltet)

  2. qiskit/granite-8b-qiskit - Veröffentlicht im November 2024 (veraltet)

Weitere Informationen und Zitationen​

Um mehr über Qiskit Code Assistant, die Qiskit HumanEval- oder Qiskit HumanEval Hard-Benchmarks zu erfahren und sie in deinen wissenschaftlichen Veröffentlichungen zu zitieren, sieh dir diese empfohlenen Zitationen an:

@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},
}

Quelle: IBM Quantum-Dokumentation — aktualisiert 22. Mai 2026
Englische Version auf doQumentation — aktualisiert 22. Mai 2026
Problem mit Website oder Übersetzung?Inhaltliches Problem? Auf IBM Quantum docs bearbeiten