Skip to main content
IBM Quantum Platform

Qiskit Code Assistant

Qiskit Code Assistant Os LLMs têm como objetivo tornar a computação quântica mais acessível aos novos usuários do Qiskit e melhorar a experiência de programação para os usuários atuais. Ele é treinado utilizando milhões de tokens de texto do site Qiskit SDK, anos de exemplos de código do Qiskit e recursos do site IBM Quantum®. Qiskit Code Assistant pode ajudar no seu fluxo de trabalho de desenvolvimento de sistemas quânticos, oferecendo sugestões geradas por LLM com base em IBM, Granite e outros modelos de código aberto, que incorporam os recursos e funcionalidades mais recentes de IBM®.

Notas

O Grande Modelo de Linguagem (LLM) por trás do Qiskit Code Assistant

Para fornecer sugestões de código, o Qiskit Code Assistant utiliza um Modelo de Linguagem Grande (LLM). Neste caso, Qiskit Code Assistant atualmente se baseia no modelo mistral-small-3.2-24b-qiskit, construído com base no modelo Mistral-Small-3.2-24B-Qiskit. O mistral-small-3.2-24b-qiskit modelo aprimora os recursos de geração Mistral-Small-3.2-24B-Instruct-2506 de código do modelo para o Qiskit por meio de pré-treinamento estendido e ajuste fino em dados Qiskit de alta qualidade, bem como commits e bate-papos no Python. Para obter mais informações sobre a família de modelos Mistral AI, consulte a documentação da Mistral AI. Para obter mais detalhes sobre os .*-qiskit modelos, consulte Qiskit Code Assistant : Treinamento de LLMs para geração de código de computação quântica.

Nossos LLMs especializados para o Qiskit também estão disponíveis como modelos de código aberto. Confira todos os modelos disponíveis em https://huggingface.co/Qiskit.

Os benchmarks Qiskit HumanEval e Qiskit HumanEval Hard

Para testar o mistral-small-3.2-24b-qiskit e outros modelos, colaboramos com os Qiskit Advocates e especialistas para criar os benchmarks baseados em execução chamados Qiskit HumanEval (QHE) e Qiskit HumanEval Hard (QHE Hard) e os executamos nos modelos. Esses benchmarks são semelhantes ao HumanEval, incluindo vários problemas de código desafiadores a serem resolvidos, todos baseados nas bibliotecas oficiais do Qiskit.

Os benchmarks são compostos por aproximadamente 150 testes, cada um deles criado a partir de uma definição de função, seguida por uma string de documentação que detalha a tarefa que o modelo deve resolver. Cada exemplo também inclui uma solução canônica de referência, bem como testes unitários, para avaliar a correção das soluções geradas. Existem três níveis de dificuldade para os testes: básico, intermediário e difícil. O benchmark Qiskit HumanEval Hard é uma variação do Qiskit HumanEval One, mas remove informações relacionadas a importações de código, de modo que o LLM precisa descobrir o método ou as importações de classe corretas. De acordo com nossos testes e resultados iniciais, essa mudança torna o conjunto de dados muito mais desafiador para os LLMs.

Os conjuntos de dados para Qiskit HumanEval e Qiskit HumanEval Hard estão disponíveis nos seguintes sites: Qiskit HumanEval e Qiskit HumanEval. Você pode contribuir para o desenvolvimento desses benchmarks no repositório GitHub.

Instale o Qiskit Code Assistant

Aprenda a instalar, configurar e usar qualquer um dos modelos do Qiskit Code Assistant em seu computador.

  • Siga estas etapas para baixar qualquer modelo relacionado ao Qiskit Code Assistant do site Hugging Face :

    1. Acesse a página do modelo Qiskit desejado em Hugging Face.
    2. Vá até a guia “Arquivos e Versões” e baixe os arquivos de modelo safetensors ou GGUF.

  • Para baixar qualquer um dos modelos disponíveis no Qiskit Code Assistant usando a CLI do Hugging Face, siga estas etapas:

    1. Instale a CLI do Hugging Face

    2. Faça login na sua conta Hugging Face

      huggingface-cli login

    3. Baixe o modelo de sua preferência da lista anterior

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

  • Existem várias maneiras de implementar e interagir com o modelo baixado do Qiskit Code Assistant. Este guia demonstra como usar Ollama da seguinte forma: seja com o Aplicativo Ollama por meio da integração do Hugging Face Hub ou do modelo local, seja com o llama-cpp-python pacote.

    Como usar o aplicativo Ollama

    O aplicativo Ollama oferece uma solução simples para executar os LLMs localmente. É fácil de usar, com uma interface de linha de comando (CLI) que torna todo o processo de configuração, gerenciamento de modelos e interação bastante simples. É ideal para experiências rápidas e para usuários que preferem lidar com menos detalhes técnicos.

    Instalar o Ollama

    1. Baixe o aplicativo Ollama

    2. Instale o arquivo baixado

    3. Inicie o aplicativo Ollama instalado

      Info

      O aplicativo está funcionando corretamente quando o ícone do Ollama aparece na barra de menus da área de trabalho. Você também pode verificar se o serviço está em execução acessando http://localhost:11434/.

    4. Experimente o Ollama no seu terminal e comece a executar modelos. Por exemplo:

      ollama run hf.co/Qiskit/Qwen2.5-Coder-14B-Qiskit
    Configure o Ollama usando a integração com o Hub do Hugging Face

    A integração do Ollama com o Hub Hugging Face permite interagir com modelos hospedados no Hub Hugging Face sem a necessidade de criar um novo arquivo de modelo nem de baixar manualmente os arquivos GGUF ou safetensors. Os arquivos template``params padrão já estão incluídos para o modelo no Hub do Hugging Face.

    1. Certifique-se de que o aplicativo Ollama esteja em execução.

    2. Acesse a página do modelo desejado e copie o link URL. Por exemplo, https://huggingface.co/Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF.

    3. No seu terminal, execute o comando:

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

    Você pode usar o hf.co/Qiskit/Qwen2.5-Coder-14B-Qiskit modelo ou qualquer um dos outros modelos oficiais da GGUF atualmente hf.co/Qiskit/mistral-small-3.2-24b-qiskit-GGUF recomendados ou hf.co/Qiskit/granite-3.3-8b-qiskit-GGUF.

    Configure o Ollama com um modelo GGUF do site Qiskit Code Assistant baixado manualmente

    Se você baixou manualmente um modelo GGUF, como https://huggingface.co/Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF, e deseja experimentar diferentes modelos e parâmetros, siga estas etapas para carregá-lo em sua aplicação local do Ollama.

    1. Crie um Modelfile inserindo o seguinte conteúdo e certifique-se de atualizar <PATH-TO-GGUF-FILE> para o caminho real do modelo que você baixou.

      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. Execute o seguinte comando para criar uma instância de modelo personalizada com base no Modelfile.

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

      Esse processo pode demorar algum tempo para que o Ollama leia o arquivo do modelo, inicialize a instância do modelo e a configure de acordo com as especificações fornecidas.

    Execute manualmente o modelo “ Qiskit Code Assistant ” baixado no Ollama

    Depois que Qwen2.5-Coder-14B-Qiskit o modelo estiver configurado no Ollama, execute o seguinte comando para iniciar o modelo e interagir com ele no terminal (no modo de bate-papo).

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

    Alguns comandos úteis:

    • ollama list - Listar os modelos no seu computador
    • ollama rm Qwen2.5-Coder-14B-Qiskit - Excluir o modelo
    • ollama show Qwen2.5-Coder-14B-Qiskit - Mostrar informações do modelo
    • ollama stop Qwen2.5-Coder-14B-Qiskit - Interromper um modelo que está em execução
    • ollama ps - Listar quais modelos estão carregados no momento

  • Uma alternativa ao aplicativo Ollama é o llama-cpp-python pacote, que é uma ligação do Python para llama.cpp. Isso oferece mais controle e flexibilidade para executar o modelo GGUF localmente e é ideal para usuários que desejam integrar o modelo local em seus fluxos de trabalho e em aplicaçõ Python es.

    1. Instalar llama-cpp-python
    2. Interaja com o modelo a partir do seu aplicativo usando llama_cpp. Por exemplo:
    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"]

    Você também pode adicionar parâmetros de geração de texto ao modelo para personalizar a inferência:

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

  • Use a llama.cpp biblioteca

    Outra alternativa é usar llama.cpp, uma biblioteca de código aberto para realizar inferência de LLM em uma CPU com configuração mínima. Ele oferece controle de baixo nível sobre a execução do modelo e é normalmente executado a partir da linha de comando, indicando um arquivo de modelo GGUF local.

    Existem várias maneiras de instalar llama.cpp no seu computador:

    Depois de instalado, você pode usar llama.cpp para interagir com os modelos GGUF no modo de conversa da seguinte maneira:

    # 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

    Você também pode iniciar um servidor API do OpenAI-compatible para o modelo da seguinte maneira:

    llama-server -hf Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF
    Parâmetros avançados

    Com o llama-cli programa, você pode controlar a geração do modelo usando opções de linha de comando. Por exemplo, você pode definir um prompt inicial do “sistema” usando o -p/--prompt sinalizador. No modo de conversa (-cnv), este prompt inicial funciona como a mensagem do sistema. Caso contrário, basta adicionar qualquer instrução desejada no início do texto do prompt. Você também pode ajustar os parâmetros de amostragem — por exemplo: temperatura (--temp), top-k (--top-k), top-p (--top-p), penalidade de repetição (--repeat-penalty) e a semente a ser usada (--seed). Segue abaixo um exemplo de chamada utilizando essas opções:

    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

    Para garantir o funcionamento adequado dos nossos modelos Qiskit, recomendamos o uso do prompt de sistema fornecido em nossos repositórios HF GGUF: prompt de sistema para mistral-small-3.2-24b-qiskit-GGUF, Qwen2.5-Coder-14B-Qiskit-GGUF, granite-3.3-8b-qiskit-GGUF e granite-3.2-8b-qiskit-GGUF.

  • Continuar (VS Code)

    1. Instale a extensão

    Abra o VS Code, vá até Extensões (Cmd+Shift+X), procure por Continue e instale-o.

    2. Abra o arquivo de configuração

    Clique no ícone “Continuar” na barra lateral e, em seguida, clique no ícone de engrenagem ou abra a paleta de comandos (Cmd+Shift+P) e execute “Continuar: Abrir arquivo de configuração ”.

    Isso abre ~/.continue/config.yaml (ou config.json em versões mais antigas).

    3. Configurar o modelo

    config.yamlAdicione o seguinte a:

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

    Isso torna o modelo do Qiskit disponível no painel de bate-papo (conversas na barra lateral, perguntas e respostas embutidas) e para comandos de edição embutidos.

    4. Teste

    • Bate-papo: Abra o painel “Continuar” na barra lateral e faça uma pergunta (por exemplo: “Como faço para criar um circuito parametrizado no Qiskit?”)

    • Edição direta: Selecione um bloco de código e pressione Cmd+I (Mac) ou Ctrl+I ( Linux /Windows)

  • Jupyter AI ( JupyterLab )

    Observação: Estas instruções se aplicam ao Jupyter AI v2.x.

    1. Instale o Jupyter AI e o provedor Ollama
    pip install "jupyter-ai<3" langchain-ollama

    O "jupyter-ai<3" pino garante que você receba um v2.x O langchain-ollama pacote é necessário para que o Jupyter AI reconheça o Ollama como provedor. Sem isso, o Ollama não aparecerá no painel de configurações.

    Em seguida, reinicie o JupyterLab.

    2. Configurar o modelo de chat

    Acesse JupyterLab e clique no ícone de chat na barra lateral esquerda. No painel de configurações:

    1. Em “Modelo de linguagem ”, selecione Ollama como provedor.
    2. Digite mistral-small-3.2-24b-qiskit como nome do modelo.
    3. Não é necessária nenhuma chave de API para o Ollama (deixe o campo em branco).
    4. Clique na seta para trás para começar a conversar.
    3. Use o comando mágico %%ai

    Essa %%ai funcionalidade permite consultar o modelo diretamente nas células do notebook.

    %load_ext jupyter_ai_magics

    Em seguida, em uma célula:

    %%ai ollama:mistral-small-3.2-24b-qiskit
Write a function that implements Grover's algorithm using Qiskit
    4. Servidor Ollama personalizado (opcional)

    Por padrão, o Jupyter AI se conecta a http://127.0.0.1:11434. Se o seu servidor Ollama estiver em execução em um endereço ou porta diferente:

    Na interface do chat: defina o campo “ URL da API de base” no painel de configurações de IA.

  • OpenCode (Terminal)

    1. Instale o OpenCode
    curl -fsSL https://opencode.ai/install | bash
    2. Configurar o modelo do Qiskit

    Crie um opencode.json arquivo na raiz do seu projeto (ou ~/.config/opencode/opencode.json para uma configuração global):

    {
  "$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. Selecione o modelo

    Execute o comando OpenCode no diretório do seu projeto:

    opencode

    No TUI, execute o /models comando e selecione “ Qiskit Code Assistant ” na lista.

    4. Teste

    Faça uma pergunta diretamente no chat, por exemplo: "Defina um circuito de Bell e execute-o usando QiskitRuntimeService"" "

Modelos disponíveis

Modelos atuais

Estes são os modelos mais recentes recomendados para uso com o Qiskit Code Assistant :

  1. Qiskit/mistral-small-3.2-24b-qiskit - Lançado em outubro de 2025
  2. Qiskit/Qwen2.5-Coder-14B-Qiskit - Lançado em junho de 2025
  3. qiskit/granite-3.3-8b-qiskit - Lançado em junho de 2025
  4. qiskit/granite-3.2-8b-qiskit - Lançado em junho de 2025

Modelos GGUF (recomendados para ambientes pessoais/laptops)

Os modelos no formato GGUF são otimizados para uso local e exigem menos recursos computacionais:

  1. mistral-small-3.2-24b-qiskit-GGUF – Lançado em outubro de 2025.
    Treinado com dados do Qiskit até a versão 2.1

  2. Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF – Lançado em junho de 2025
    . Treinado com dados do Qiskit até a versão 2.0

  3. qiskit/granite-3.3-8b-qiskit-GGUF – Lançado em junho de 2025.
    Treinado com dados do Qiskit até a versão 2.0

  4. qiskit/granite-3.2-8b-qiskit-GGUF – Lançado em junho de 2025.
    Treinado com dados do Qiskit até a versão 2.0

Os modelos de código aberto do Qiskit Code Assistant estão disponíveis em O Safetensors é um formato de arquivo desenvolvido especificamente para armazenar pesos e tensores de modelos de aprendizado de máquina de maneira segura e eficiente. ou O GGUF é um formato binário projetado para carregar e salvar modelos rapidamente, além de oferecer boa legibilidade. e podem ser baixados do site Hugging Face, conforme explicado a seguir.

Versões do Qiskit utilizadas para o treinamento

Modelo
 
 
 
 
 
Métricas de referência
 
 
 
 
Data de liberação
Treinado na versão do Qiskit
 QiskitHumanEval-HardQiskitHumanEvalHumanEvalASDivMathQASciQMBPPIFEvalCrowsPairs (Inglês)TruthfulQA (Conta do MC1 )  
mistral-small-3.2-24b-qiskit32.4547.0277.493.7749.6897.5064.0048.4467.0839.41Janeiro de 20262.2
Qwen2.5-Coder-14B-Qiskit25.1749.0191.464.2153.9097.0077.6049.6465.1837.82Junho de 20252.0
granite-3.3-8b-qiskit14.5727.1562.800.4838.6693.3052.4059.7159.7539.05Junho de 20252.0
granite-3.2-8b-qiskit9.9324.5057.320.0941.4196.3051.8060.7966.7940.51Junho de 20252.0
granite-8b-qiskit-rc-0.1015.8938.4159.76———————Fevereiro de 20251.3
granite-8b-qiskit17.8844.3753.66———————Novembro de 20241.2

Nota: Todos os modelos listados na tabela de comparação foram avaliados utilizando o prompt de sistema respectivo, definido no modelo Hugging Face.

Modelos obsoletos

Esses modelos não recebem mais atualizações, mas continuam disponíveis:

  1. qiskit/granite-8b-qiskit-rc-0.10 - Lançado em fevereiro de 2025 (obsoleto)
  2. qiskit/granite-8b-qiskit - Lançado em novembro de 2024 (obsoleto)

Mais informações e citações

Para saber mais sobre Qiskit Code Assistant os benchmarks Qiskit HumanEval, ou Qiskit HumanEval Hard e citá-los em suas publicações científicas, consulte estas citações recomendadas:

@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},
}
Esta página foi útil?
Relate um bug, erro de digitação ou solicite conteúdo no GitHub.