As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Solução de problemas de cenários de geração de código no Amazon Q Developer Você pode encontrar os seguintes cenários comuns com geração de código e resoluções imprecisas ao usar o Amazon Q Developer: + [Geração de código vazio](#suggestions-troubleshooting) + [Comentários contínuos](#comments-troubleshooting) + [Geração incorreta de código em linha](#code-generation-troubleshooting) + [Resultados inadequados de bate-papos](#chat-results-troubleshooting) ## Geração de código vazio Ao desenvolver o código, você pode observar os seguintes problemas: + O Amazon Q não fornece uma sugestão. + A mensagem “Nenhuma sugestão do Amazon Q” aparece em seu IDE. Seu primeiro pensamento pode ser que o Amazon Q não está funcionando corretamente. No entanto, a causa raiz desses problemas geralmente está associada ao contexto no script ou ao projeto aberto no IDE. Se o Amazon Q Developer não fornecer uma sugestão automaticamente, você poderá usar os seguintes atalhos para executar manualmente as sugestões em linha do Amazon Q: + PC**** - **Alt\+C** + **macOS - Opção\+C** Para obter mais informações, consulte [Usando teclas de atalho](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/actions-and-shortcuts.html) no *Amazon Q Developer User Guide*. Na maioria dos cenários, o Amazon Q gera uma sugestão. Quando o Amazon Q retornar uma mensagem “Nenhuma sugestão da Amazon Q”, revise as seguintes resoluções comuns para esse problema: + **Contexto inadequado** — Certifique-se de que as bibliotecas aplicáveis estejam presentes. Certifique-se de que as classes e funções definidas no script estejam relacionadas ao novo código. + **Solicitação ambígua** — Se a solicitação for confusa ou obscura, o Amazon Q terá um desempenho inferior ao fazer sugestões de código em linha. Nesses cenários, seja mais específico em seu código e comentários para obter respostas adequadas. Se você estiver preso, continue programando da melhor maneira possível. Normalmente, o Amazon Q reconhece sua intenção, o que faz com que ele ofereça sugestões. Outra opção é enviar um trecho de código com instruções imediatas em um chat do Amazon Q. Para obter mais informações, consulte [Enviar código para o Amazon Q](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/explain-update-code.html#send-code) no *Guia do usuário do desenvolvedor do Amazon Q.* ## Comentários contínuos Você pode escrever uma solicitação usando comentários e receber apenas linhas de comentários genéricas ou repetidas da Amazon Q. Entrada: ``` // Kafka test ``` Resultado: ``` // Kafka test // Kafka test // Kafka test // Kafka test ``` Normalmente, esse problema ocorre devido à falta de contexto no script ou às instruções de aviso inadequadas. Recomendamos que você use o formato padrão para comentários de acordo com o idioma. Neste exemplo, o usuário alterou o prompt `/* */ ` para usar em um bloco de comentários, e essa alteração resultou em um melhor desempenho do Amazon Q. Entrada: ``` /* * Create a unit test to push a message to a Kafka topic */ ``` Resultado: Nesse resultado, o usuário aceitou várias sugestões sequencialmente. ``` /* * Create a unit test to push a message to a Kafka topic */ import org.junit.Test; import java.util.Properties; import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord; import static org.junit.Assert.assertEquals; // create function for a Kafka test public class KafkaTest { @Test public void testKafka() { // create Kafka producer Properties props = new Properties(); props.put("bootstrap.servers", "localhost:9092"); props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); KafkaProducer producer = new KafkaProducer<>(props); // create Kafka topic String topic = "test"; // send message to Kafka topic producer.send(new ProducerRecord<>(topic, "key", "value")); // close Kafka producer producer.close(); // assert that message was sent successfully assertEquals("value", KafkaTest.consumer.poll().value()); } } ``` ## Geração incorreta de código em linha Ocasionalmente, as sugestões em linha do Amazon Q Developer não são úteis ou não atendem ao objetivo do seu prompt. Às vezes, sugestões de código em linha podem fornecer uma função genérica semelhante a um método simples do Hello World. Quando as sugestões de código em linha não forem úteis, experimente as seguintes práticas recomendadas: + Analise o contexto do script. Normalmente, quanto mais contexto você fornece, melhores resultados você obtém do Amazon Q. + Se a variação do contexto and/or for ruidosa, modularize seu código. Agrupe funções semelhantes no mesmo script. Separe diferentes classes e funções de acordo com seus objetivos. + Escreva seus nomes de classes e funções de forma tática para ajudar a Amazon Q a fornecer recomendações melhores. Neste exemplo, o desenvolvedor está escrevendo um script do zero que carrega arquivos para o Hadoop. Entrada: ``` class MyFunction{ // create function to read data locally and upload to HDFS filesystem ``` Resultado: ``` class MyFunction{ // create function to read local data file path and upload to HDFS filesystem public void readAndUploadToHDFS(String inputPath, String outputPath) throws IOException { // read data from local file BufferedReader in = new BufferedReader(new FileReader(inputPath)); } ``` Embora o Amazon Q tenha fornecido uma recomendação, ela não atendeu à expectativa do desenvolvedor. Para melhorar o desempenho, o desenvolvedor importa bibliotecas e altera o nome da classe para representar os utilitários do Hadoop. Correção: ``` import java.io.BufferedReader; import java.io.IOException; import java.io.FileReader; // import applicable hadoop libraries for IO operations import org.apache.hadoop.fs.Path; class HadoopUtilities{ // create function to read local data file path and upload to HDFS filesystem } ``` Resultado: Nesse resultado, o desenvolvedor aceitou várias sugestões sequencialmente. ``` class HadoopUtilities{ // create function to read local data file path and upload to HDFS filesystem public static void uploadToHDFS(String localFilePath, String hdfsFilePath) throws IOException { // create HDFS file path object Path hdfsPath = new Path(hdfsFilePath); // create local file path object Path localPath = new Path(localFilePath); // create hadoop file system object org.apache.hadoop.fs.FileSystem hdfs = org.apache.hadoop.fs.FileSystem.get(new org.apache.hadoop.conf.Configuration()); // upload local file to HDFS hdfs.copyFromLocalFile(localPath, hdfsPath); // close HDFS file system hdfs.close(); System.out.println("File uploaded successfully!"); } ``` No mesmo HadoopUtilities script, o desenvolvedor adiciona um prompt de comentário para ler um tópico do Amazon Simple Queue Service (Amazon SQS). Entrada: ``` // read message from SQS ``` Resultado: ``` // read message from SQS public static void readMessageFromSQS(String message) { System.out.println("Received message from SQS: " + message); ``` Em vez de usar métodos Java para ler uma mensagem SQS do Amazon SQS, o Amazon Q sugere imprimir um método de string. No entanto, essa sugestão não satisfaz o objetivo original do desenvolvedor. Nesse caso, é preferível remodularizar o código. O foco do script está nos métodos do Hadoop. Portanto, pode ser uma abordagem melhor criar um script utilitário específico para operações do SQS. A criação de uma classe separada para utilitários SQS melhora a sugestão em linha, que pode ser usada no script. HadoopUtilities Entrada: ``` // import function for SQS import com.amazonaws.services.sqs.AmazonSQS; import java.util.ArrayList; import java.util.List; class SQSUtils { // instantiate SQS client private AmazonSQS sqsClient; // load SQS object public SQSUtils(AmazonSQS sqsClient) { this.sqsClient = sqsClient; } // poll message from Amazon SQS given queue name } ``` Resultado: ``` // poll message from Amazon SQS given queue name public List pollMessages(String queueName) { List messages = new ArrayList<>(); // poll messages from queue receiveMessageResult = sqsClient.receiveMessage(new ReceiveMessageRequest(queueName)); for (Message message : receiveMessageResult.getMessages()) { messages.add(message.getBody()); } return messages; ``` Se a sugestão em linha ainda não estiver fornecendo os resultados esperados, peça ao Amazon Q Developer em uma sessão de bate-papo para gerar o código. ### Converse sobre a geração de código Usuário: Gere uma função java para ler uma mensagem de uma fila do Amazon SQS Amazon Q: Aqui está um exemplo de função Java para ler uma mensagem de uma fila do Amazon SQS: ``` import com.amazonaws.services.sqs.AmazonSQS; import com.amazonaws.services.sqs.model.Message; import com.amazonaws.services.sqs.model.ReceiveMessageRequest; import com.amazonaws.services.sqs.model.ReceiveMessageResult; public class SQSMessageReader { private AmazonSQS sqsClient; private String queueUrl; public SQSMessageReader(AmazonSQS sqsClient, String queueUrl) { this.sqsClient = sqsClient; this.queueUrl = queueUrl; } public String readMessage() { ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(queueUrl) .withMaxNumberOfMessages(1) .withWaitTimeSeconds(10); ReceiveMessageResult receiveMessageResult = sqsClient.receiveMessage(receiveMessageRequest); if (receiveMessageResult.getMessages().size() > 0) { Message message = receiveMessageResult.getMessages().get(0); String messageBody = message.getBody(); String receiptHandle = message.getReceiptHandle(); // Process the message System.out.println("Received message: " + messageBody); // Delete the message from the queue sqsClient.deleteMessage(queueUrl, receiptHandle); return messageBody; } else { return null; } } ``` Esse código cria uma classe SQSMessage Reader que usa um cliente AmazonSQS e uma URL de fila como parâmetros do construtor. O método readMessage () usa o ReceiveMessageRequest para buscar até 1 mensagem da fila, com um tempo máximo de espera de 10 segundos. Se uma mensagem for recebida, o corpo da mensagem será impresso e a mensagem será excluída da fila usando o. DeleteMessageRequest O corpo da mensagem é então retornado. Se nenhuma mensagem for recebida, null será retornado. **Encerre** **o bate-papo do Amazon Q sobre a geração de código** ## Resultados inadequados de bate-papos Ao desenvolver o código, os desenvolvedores podem pedir à Amazon Q que gere funções comuns, forneça recomendações ou explique o código. Às vezes, após receber uma solicitação (como uma pergunta ou um trecho de código), o Amazon Q pode fornecer feedback geral ou resultados que não atendem às suas expectativas. Nesses cenários, tente o seguinte: + Experimente diferentes instruções para melhorar os resultados de geração de código que você obtém do Amazon Q. + Siga o URLs que o Amazon Q frequentemente fornece em suas respostas às suas solicitações ou perguntas. + Forneça feedback para ajudar a melhorar o desempenho futuro do Amazon Q. Por exemplo, um desenvolvedor está criando uma solução de Retrieval Augmented Generation (RAG) e precisa fragmentar o documento de acordo com as relações semânticas entre as frases. O desenvolvedor conversa com o Amazon Q da seguinte forma. ### Converse sobre uma solução RAG Usuário: Para uma solução RAG, gere código para fragmentação semântica Amazon Q: Certamente, aqui está um exemplo de como você pode implementar a fragmentação semântica para uma solução de Geração Aumentada de Recuperação (RAG) usando a biblioteca: Python LangChain ``` from langchain.text_splitter import CharacterTextSplitter, TokenTextSplitter from langchain.embeddings import HuggingFaceEmbeddings from langchain.vectorstores import Chroma # Initialize the text splitter text_splitter = TokenTextSplitter( chunk_size=500, chunk_overlap=50, length_function=len ) # Initialize the embeddings model embeddings = HuggingFaceEmbeddings() # Create the vector store vectorstore = Chroma( embedding_function=embeddings.embed_documents, persist_directory="./chroma-data" ) # Chunk the text using semantic similarity def semantic_chunk(text): chunks = text_splitter.split_text(text) embeddings = embeddings.embed_documents(chunks) vectorstore.add_texts(chunks, embeddings) return chunks ``` Neste exemplo, estamos usando o TokenTextSplitter de LangChain para dividir o texto de entrada em partes de 500 caracteres com uma sobreposição de 50 caracteres. O HuggingFaceEmbeddings modelo é usado para gerar incorporações para cada fragmento, e o armazenamento Chroma vetorial é usado para armazenar os fragmentos e suas incorporações. A função semantic\_chunk pega o texto de entrada, o divide em partes usando o text\_splitter, gera incorporações para cada bloco usando o modelo de incorporações e, em seguida, adiciona as partes e suas incorporações ao. vectorstore Essa abordagem permite dividir o texto de entrada em partes semanticamente significativas, que podem ser úteis para uma variedade de tarefas, como responder a perguntas ou resumir, em uma solução RAG. Observe que este é um exemplo básico e talvez seja necessário ajustar os parâmetros (por exemplo, chunk\_size, chunk\_overlap) ou a escolha do divisor de texto e do modelo de incorporação com base em seu caso de uso e dados específicos. **Fim do bate-papo do Amazon Q** **sobre uma solução RAG** No entanto, essa abordagem fornece apenas uma maneira básica de fragmentar documentos usando a técnica de janela deslizante. O desenvolvedor quer uma forma avançada que dependa da medição de incorporações. Nesses cenários, o desenvolvedor deve adicionar mais detalhes ao prompt de acordo com seu objetivo. Quando o desenvolvedor se refere à conhecida função de divisor de AI21 texto com LangChain, ele recebe uma resposta aprimorada, conforme mostrado no bate-papo a seguir. ### Converse sobre uma solução RAG (com aviso aprimorado) Usuário: A solicitação acima se refere apenas à divisão em relação ao tamanho do token por bloco. Eu quero usar o divisor de texto AI21 semântico. Gere uma função usando a divisão semântica de texto A121 com langchain. Amazon Q: Ok, vamos usar o Divisor de Texto AI21 Semântico com LangChain para implementar a fragmentação semântica. Aqui está um exemplo: [1] ``` from langchain.text_splitter import AI21SemanticTextSplitter from langchain.embeddings import HuggingFaceEmbeddings from langchain.vectorstores import Chroma # Initialize the text splitter text_splitter = AI21SemanticTextSplitter() # Initialize the embeddings model embeddings = HuggingFaceEmbeddings() # Create the vector store vectorstore = Chroma( embedding_function=embeddings.embed_documents, persist_directory="./chroma-data" ) # Chunk the text using semantic similarity def semantic_chunk(text): chunks = text_splitter.split_text(text) embeddings = embeddings.embed_documents(chunks) vectorstore.add_texts(chunks, embeddings) return chunks ``` Neste exemplo, estamos usando o AI21 SemanticTextSplitter from LangChain para dividir o texto de entrada em partes semanticamente significativas. O HuggingFaceEmbeddings modelo é usado para criar incorporações para cada fragmento, e o armazenamento Chroma vetorial é usado para armazenar os fragmentos e suas incorporações. A função semantic\_chunk pega o texto de entrada, o divide em partes usando o text\_splitter, cria incorporações para cada bloco usando o modelo de incorporações e, em seguida, adiciona as partes e suas incorporações ao. vectorstore Essa abordagem permite dividir o texto de entrada em partes semanticamente significativas, que podem ser úteis para uma variedade de tarefas, como responder a perguntas ou resumir, em uma solução RAG. Observe que talvez seja necessário ajustar os parâmetros ou a escolha do modelo de incorporação com base em seu caso de uso e dados específicos. Fontes [1] Aprenda a usar divisores de texto em LangChain [soosweb3.hashnode.dev > -divisores de texto the-ultimate-langchain-series](https://blog.davideai.dev/the-ultimate-langchain-series-text-splitters) **Fim do bate-papo do Amazon Q** **sobre uma solução RAG** **(com aviso aprimorado**) Com base nos resultados do bate-papo, o desenvolvedor pode usar a função e navegar até a fonte das informações. Em geral, tópicos e perguntas avançadas exigem um contexto mais específico no prompt quando você conversa com o Amazon Q Developer. Se você acredita que os resultados do seu bate-papo não são precisos, use o ícone de polegar para baixo para fornecer feedback sobre a resposta do Amazon Q. O Amazon Q Developer usa continuamente o feedback para melhorar futuros lançamentos. Para interações que produziram resultados positivos, é útil fornecer seu feedback usando o ícone de polegar para cima.